[analysis api, refactoring] move base test cases to base modules, improve service names

analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/AnalysisApiFe10TestConfiguratorFactory.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.analysis.api.fe10
 import org.jetbrains.kotlin.analysis.test.framework.*
 
 object AnalysisApiFe10TestConfiguratorFactory : AnalysisApiTestConfiguratorFactory() {
-    override fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfiguratorService {
+    override fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfigurator {
         require(supportMode(data))
 
         return when (data.moduleKind) {
             TestModuleKind.Source -> when (data.analysisSessionMode) {
-                AnalysisSessionMode.Normal -> KtFe10AnalysisApiTestConfiguratorService
+                AnalysisSessionMode.Normal -> AnalysisApiFirTestConfigurator
                 AnalysisSessionMode.Dependent -> error("Unsupported AnalysisSessionMode.Dependent for fe10")
             }
 

analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/KtFe10AnalysisApiTestConfiguratorService.kt

@@ -1,90 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fe10
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
-import org.jetbrains.kotlin.analysis.api.descriptors.CliFe10AnalysisFacade
-import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisHandlerExtension
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSessionProvider
-import org.jetbrains.kotlin.analysis.api.descriptors.references.base.KtFe10KotlinReferenceProviderContributor
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.extensions.AnalysisHandlerExtension
-import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.test.bind
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import org.jetbrains.kotlin.test.services.compilerConfigurationProvider
-import java.nio.file.Path
-import kotlin.io.path.extension
-import kotlin.io.path.nameWithoutExtension
-
-object KtFe10AnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val analyseInDependentSession: Boolean get() = false
-
-    override val testPrefix: String
-        get() = "descriptors"
-
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        usePreAnalysisHandlers(::KtFe10ModuleRegistrarPreAnalysisHandler.bind(disposable))
-    }
-
-    @OptIn(InvalidWayOfUsingAnalysisSession::class)
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        project.registerService(KtAnalysisSessionProvider::class.java, KtFe10AnalysisSessionProvider())
-        project.registerService(Fe10AnalysisFacade::class.java, CliFe10AnalysisFacade(project))
-        AnalysisHandlerExtension.registerExtension(project, KtFe10AnalysisHandlerExtension())
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        if (application.getServiceIfCreated(KotlinReferenceProvidersService::class.java) == null) {
-            application.registerService(KotlinReferenceProvidersService::class.java, HLApiReferenceProviderService::class.java)
-            application.registerService(
-                KotlinReferenceProviderContributor::class.java,
-                KtFe10KotlinReferenceProviderContributor::class.java
-            )
-        }
-    }
-
-    override fun prepareTestFiles(files: List<KtFile>, module: TestModule, testServices: TestServices) {
-        val compilerConfigurationProvider = testServices.compilerConfigurationProvider
-        val project = compilerConfigurationProvider.getProject(module)
-        val compilerConfiguration = compilerConfigurationProvider.getCompilerConfiguration(module)
-        val packageProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module)
-        JvmResolveUtil.analyze(project, files, compilerConfiguration, packageProviderFactory)
-    }
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        // TODO not supported yet
-    }
-
-    override fun preprocessTestDataPath(path: Path): Path {
-        val newPath = path.resolveSibling(path.nameWithoutExtension + "." + testPrefix + "." + path.extension)
-        if (newPath.toFile().exists()) return newPath
-        return path
-    }
-}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/AnalysisApiFirTestConfiguratorFactory.kt

@@ -5,28 +5,28 @@
 
 package org.jetbrains.kotlin.analysis.api.fir
 
-import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.binary.LibraryAnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.source.LibrarySourceAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.binary.LibraryAnalysisApiTestConfigurator
+import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.source.LibrarySourceAnalysisApiTestConfigurator
 import org.jetbrains.kotlin.analysis.test.framework.*
 
 object AnalysisApiFirTestConfiguratorFactory : AnalysisApiTestConfiguratorFactory() {
-    override fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfiguratorService {
+    override fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfigurator {
         require(supportMode(data))
 
         return when (data.moduleKind) {
             TestModuleKind.Source -> when (data.analysisSessionMode) {
-                AnalysisSessionMode.Normal -> FirAnalysisApiNormalModeTestConfiguratorService
-                AnalysisSessionMode.Dependent -> FirAnalysisApiDependentModeTestConfiguratorService
+                AnalysisSessionMode.Normal -> AnalysisApiFirTestConfigurator(analyseInDependentSession = false)
+                AnalysisSessionMode.Dependent -> AnalysisApiFirTestConfigurator(analyseInDependentSession = true)
             }
 
             TestModuleKind.LibraryBinary -> {
                 require(data.analysisSessionMode == AnalysisSessionMode.Normal)
-                LibraryAnalysisApiTestConfiguratorService
+                LibraryAnalysisApiTestConfigurator
             }
 
             TestModuleKind.LibrarySource -> {
                 require(data.analysisSessionMode == AnalysisSessionMode.Normal)
-                LibrarySourceAnalysisApiTestConfiguratorService
+                LibrarySourceAnalysisApiTestConfigurator
             }
         }
     }

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirAnalysisApiTestConfiguratorService.kt

@@ -1,64 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fir
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.fir.utils.configureOptionalTestCompilerPlugin
-import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.FirLowLevelAnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.idea.references.KotlinFirReferenceContributor
-import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-
-open class FirAnalysisApiTestConfiguratorService(override val analyseInDependentSession: Boolean) : AnalysisApiTestConfiguratorService {
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        with(FirLowLevelAnalysisApiTestConfiguratorService) { configureTest(disposable) }
-        configureOptionalTestCompilerPlugin()
-    }
-
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        FirLowLevelAnalysisApiTestConfiguratorService.registerProjectServices(
-            project,
-            compilerConfig,
-            files,
-            packagePartProvider,
-            projectStructureProvider,
-            jarFileSystem
-        )
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        FirLowLevelAnalysisApiTestConfiguratorService.registerApplicationServices(application)
-        if (application.getServiceIfCreated(KotlinReferenceProvidersService::class.java) == null) {
-            application.registerService(KotlinReferenceProvidersService::class.java, HLApiReferenceProviderService::class.java)
-            application.registerService(KotlinReferenceProviderContributor::class.java, KotlinFirReferenceContributor::class.java)
-        }
-    }
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        FirLowLevelAnalysisApiTestConfiguratorService.doOutOfBlockModification(file)
-    }
-}
-
-object FirAnalysisApiDependentModeTestConfiguratorService: FirAnalysisApiTestConfiguratorService(analyseInDependentSession = true)
-object FirAnalysisApiNormalModeTestConfiguratorService: FirAnalysisApiTestConfiguratorService(analyseInDependentSession = false)

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/importOptimizer/AbstractHLImportOptimizerTest.kt

@@ -1,29 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fir.components.importOptimizer
-
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import org.jetbrains.kotlin.test.services.assertions
-
-abstract class AbstractHLImportOptimizerTest : AbstractAnalysisApiBasedSingleModuleTest(){
-    override fun doTestByFileStructure(ktFiles: List<KtFile>, module: TestModule, testServices: TestServices) {
-        val mainKtFile = ktFiles.singleOrNull() ?: ktFiles.first { it.name == "main.kt" }
-        val unusedImports = analyseForTest(mainKtFile) { analyseImports(mainKtFile).unusedImports }
-
-        val unusedImportPaths = unusedImports
-            .map { it.importPath ?: error("Import $it should have an import path, instead was ${it.text}") }
-            .sortedBy { it.toString() } // for stable results
-
-        val actualUnusedImports = buildString {
-            unusedImportPaths.forEach(::appendLine)
-        }
-
-        testServices.assertions.assertEqualsToTestDataFileSibling(actualUnusedImports, extension = ".imports")
-    }
-}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/psiTypeProvider/AbstractExpressionPsiTypeProviderTest.kt

@@ -1,31 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fir.components.psiTypeProvider
-
-import org.jetbrains.kotlin.analysis.api.analyse
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
-import org.jetbrains.kotlin.psi.KtExpression
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import org.jetbrains.kotlin.test.services.assertions
-
-abstract class AbstractExpressionPsiTypeProviderTest : AbstractAnalysisApiSingleFileTest(){
-    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
-        val declarationAtCaret = testServices.expressionMarkerProvider.getSelectedElement(ktFile) as KtExpression
-        val actual = analyse(ktFile) {
-            val returnType = declarationAtCaret.getKtType()
-                ?: error("Not a typable expression ${declarationAtCaret::class} ${declarationAtCaret.text}")
-            val psiType = returnType.asPsiType(declarationAtCaret)
-            buildString {
-                appendLine("KtType: ${returnType.render()}")
-                appendLine("PsiType: $psiType")
-            }
-        }
-        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
-    }
-}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/psiTypeProvider/AbstractPsiTypeProviderTest.kt

@@ -1,98 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fir.components.psiTypeProvider
-
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiClass
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiElementVisitor
-import org.jetbrains.kotlin.analysis.api.analyse
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
-import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
-import org.jetbrains.kotlin.asJava.classes.KtLightClass
-import org.jetbrains.kotlin.asJava.elements.KtLightElement
-import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.psiUtil.parents
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import org.jetbrains.kotlin.test.services.assertions
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-
-abstract class AbstractPsiTypeProviderTest : AbstractAnalysisApiSingleFileTest(){
-    override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
-        val declaration = testServices.expressionMarkerProvider.getElementOfTypAtCaret<KtDeclaration>(ktFile)
-        val containingClass =
-            getContainingKtLightClass(declaration, ktFile)
-        val psiContext = containingClass.findLightDeclarationContext(declaration)
-            ?: error("Can't find psi context for $declaration")
-        val actual = buildString {
-            executeOnPooledThreadInReadAction {
-                analyse(declaration) {
-                    val ktType = declaration.getReturnKtType()
-                    appendLine("KtType: ${ktType.render()}")
-                    appendLine("PsiType: ${ktType.asPsiType(psiContext)}")
-                }
-            }
-        }
-        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
-    }
-
-    private fun getContainingKtLightClass(
-        declaration: KtDeclaration,
-        ktFile: KtFile,
-    ): KtLightClass {
-        val project = ktFile.project
-        return createLightClassByContainingClass(declaration, project)
-            ?: getFacadeLightClass(ktFile, project)
-            ?: error("Can't get or create containing KtLightClass for $declaration")
-
-    }
-
-    private fun getFacadeLightClass(
-        ktFile: KtFile,
-        project: Project,
-    ): KtLightClass? {
-        val mainKtFileFqName = ktFile.packageFqName.child(Name.identifier(ktFile.name))
-        return project.getService(SymbolLightClassFacadeCache::class.java)
-            .getOrCreateSymbolLightFacade(listOf(ktFile), mainKtFileFqName)
-    }
-
-    private fun createLightClassByContainingClass(
-        declaration: KtDeclaration,
-        project: Project
-    ): KtLightClass? {
-        val containingClass = declaration.parents.firstIsInstanceOrNull<KtClassOrObject>() ?: return null
-        return project.getService(KotlinAsJavaSupport::class.java).getLightClass(containingClass)
-    }
-
-    private fun KtLightClass.findLightDeclarationContext(ktDeclaration: KtDeclaration): KtLightElement<*, *>? {
-        val selfOrParents = listOf(ktDeclaration) + ktDeclaration.parents.filterIsInstance<KtDeclaration>()
-        var result: KtLightElement<*, *>? = null
-        val visitor = object : PsiElementVisitor() {
-            override fun visitElement(element: PsiElement) {
-                if (element !is KtLightElement<*, *>) return
-                // NB: intentionally visit members first so that `self` can be found first if matched
-                if (element is PsiClass) {
-                    element.fields.forEach { it.accept(this) }
-                    element.methods.forEach { it.accept(this) }
-                    element.innerClasses.forEach { it.accept(this) }
-                }
-                if (result == null && element.kotlinOrigin in selfOrParents) {
-                    result = element
-                    return
-                }
-            }
-        }
-        accept(visitor)
-        return result
-    }
-
-}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/binary/LibraryAnalysisApiTestConfiguratorService.kt

@@ -1,73 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fir.utils.libraries.binary
-
-import com.intellij.ide.highlighter.JavaClassFileType
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.extensions.LoadingOrder
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.ClassFileViewProviderFactory
-import com.intellij.psi.FileTypeFileViewProviders
-import com.intellij.psi.compiled.ClassFileDecompilers
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinBuiltInDecompiler
-import org.jetbrains.kotlin.analysis.decompiler.psi.KotlinClassFileDecompiler
-import org.jetbrains.kotlin.analysis.decompiler.stub.file.ClsKotlinBinaryClassCache
-import org.jetbrains.kotlin.analysis.decompiler.stub.file.FileAttributeService
-import org.jetbrains.kotlin.analysis.decompiler.stub.files.DummyFileAttributeService
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.registerTestServices
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.analysis.test.framework.services.libraries.LibraryEnvironmentConfigurator
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-
-object LibraryAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val analyseInDependentSession: Boolean get() = false
-
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        useConfigurators(::LibraryEnvironmentConfigurator)
-        usePreAnalysisHandlers(::LibraryModuleRegistrarPreAnalysisHandler)
-    }
-
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        project.registerTestServices(files, packagePartProvider, projectStructureProvider)
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        FirAnalysisApiNormalModeTestConfiguratorService.registerApplicationServices(application)
-        if (application.getServiceIfCreated(ClsKotlinBinaryClassCache::class.java) != null) return
-        application.registerService(ClsKotlinBinaryClassCache::class.java)
-        application.registerService(FileAttributeService::class.java, DummyFileAttributeService)
-
-        FileTypeFileViewProviders.INSTANCE.addExplicitExtension(
-            JavaClassFileType.INSTANCE,
-            ClassFileViewProviderFactory()
-        )
-
-        @Suppress("DEPRECATION")
-        ClassFileDecompilers.getInstance().EP_NAME.point.apply {
-            registerExtension(KotlinClassFileDecompiler(), LoadingOrder.FIRST)
-            registerExtension(KotlinBuiltInDecompiler(), LoadingOrder.FIRST)
-        }
-    }
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        FirAnalysisApiNormalModeTestConfiguratorService.doOutOfBlockModification(file)
-    }
-}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/utils/libraries/source/LibrarySourceAnalysisApiTestConfiguratorService.kt

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.fir.utils.libraries.source
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.registerTestServices
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.analysis.test.framework.services.libraries.CompiledLibraryProvider
-import org.jetbrains.kotlin.analysis.test.framework.services.libraries.LibraryEnvironmentConfigurator
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.services.ServiceRegistrationData
-
-object LibrarySourceAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val analyseInDependentSession: Boolean get() = false
-
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        useConfigurators(::LibraryEnvironmentConfigurator)
-        usePreAnalysisHandlers(::LibrarySourceModuleRegistrarPreAnalysisHandler)
-        useAdditionalServices(ServiceRegistrationData(CompiledLibraryProvider::class, ::CompiledLibraryProvider))
-    }
-
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        project.registerTestServices(files, packagePartProvider, projectStructureProvider)
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        FirAnalysisApiNormalModeTestConfiguratorService.registerApplicationServices(application)
-    }
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        FirAnalysisApiNormalModeTestConfiguratorService.doOutOfBlockModification(file)
-    }
-}

analysis/analysis-api-impl-base/build.gradle.kts

@@ -19,6 +19,7 @@ dependencies {
     testApi(projectTests(":compiler:test-infrastructure"))
     testApi(projectTests(":compiler:tests-common-new"))
     testApi(projectTests(":analysis:analysis-api-impl-barebone"))
+    testApi(project(":analysis:symbol-light-classes"))
     testApi(projectTests(":analysis:analysis-test-framework"))
     testImplementation(project(":kotlin-reflect"))
     testImplementation(toolsJar())

analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/AbstractStandaloneModeSingleModuleTest.kt

@@ -1,57 +0,0 @@
-/*
- * 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.analysis.api.standalone
-
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
-import org.jetbrains.kotlin.analysis.api.components.RendererModifier
-import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.api.impl.base.test.TestReferenceResolveResultRenderer.renderResolvedTo
-import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
-import org.jetbrains.kotlin.analysis.test.framework.utils.findReferencesAtCaret
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import org.jetbrains.kotlin.test.services.assertions
-
-abstract class AbstractStandaloneModeSingleModuleTest : AbstractAnalysisApiBasedSingleModuleTest() {
-    override fun configureTest(builder: TestConfigurationBuilder) {
-        super.configureTest(builder)
-        with(builder) {
-            defaultDirectives {
-                +JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING
-            }
-        }
-    }
-
-    override fun doTestByFileStructure(ktFiles: List<KtFile>, module: TestModule, testServices: TestServices) {
-        val mainKtFile = ktFiles.singleOrNull() ?: ktFiles.first { it.name == "main.kt" }
-        val caretPosition = testServices.expressionMarkerProvider.getCaretPosition(mainKtFile)
-        val ktReferences = findReferencesAtCaret(mainKtFile, caretPosition)
-        if (ktReferences.isEmpty()) {
-            testServices.assertions.fail { "No references at caret found" }
-        }
-
-        val resolvedTo =
-            analyseForTest(
-                PsiTreeUtil.findElementOfClassAtOffset(mainKtFile, caretPosition, KtDeclaration::class.java, false) ?: mainKtFile
-            ) {
-                val symbols = ktReferences.flatMap { it.resolveToSymbols() }
-                renderResolvedTo(symbols, renderingOptions)
-            }
-
-        val actual = "Resolved to:\n$resolvedTo"
-        testServices.assertions.assertEqualsToTestDataFileSibling(actual)
-    }
-
-    private val renderingOptions = KtDeclarationRendererOptions.DEFAULT.copy(
-        modifiers = RendererModifier.DEFAULT - RendererModifier.ANNOTATIONS,
-        sortNestedDeclarations = true
-    )
-}

analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/AnalysisApiFirStandaloneModeTestConfiguratorFactory.kt

@@ -8,12 +8,12 @@ package org.jetbrains.kotlin.analysis.api.standalone
 import org.jetbrains.kotlin.analysis.test.framework.*
 
 object AnalysisApiFirStandaloneModeTestConfiguratorFactory : AnalysisApiTestConfiguratorFactory() {
-    override fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfiguratorService {
+    override fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfigurator {
         requireSupported(data)
 
         return when (data.moduleKind) {
             TestModuleKind.Source -> when (data.analysisSessionMode) {
-                AnalysisSessionMode.Normal -> StandaloneModeConfiguratorService
+                AnalysisSessionMode.Normal -> StandaloneModeConfigurator
                 AnalysisSessionMode.Dependent -> unsupportedModeError(data)
             }
 

analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeConfiguratorService.kt

@@ -1,53 +0,0 @@
-/*
- * 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.analysis.api.standalone
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-
-object StandaloneModeConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val analyseInDependentSession: Boolean get() = false
-
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        with(FirAnalysisApiNormalModeTestConfiguratorService) { configureTest(disposable) }
-    }
-
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        configureProjectEnvironment(
-            project,
-            compilerConfig,
-            files,
-            packagePartProvider,
-            jarFileSystem
-        )
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        configureApplicationEnvironment(application)
-    }
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        FirAnalysisApiNormalModeTestConfiguratorService.doOutOfBlockModification(file)
-    }
-}

analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeSingleModuleTestGenerated.java

@@ -1,51 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.api.standalone;
-
-import com.intellij.testFramework.TestDataPath;
-import org.jetbrains.kotlin.test.util.KtTestUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService;
-import org.jetbrains.kotlin.test.TestMetadata;
-import org.junit.jupiter.api.Test;
-
-import java.io.File;
-import java.util.regex.Pattern;
-
-/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */
-@SuppressWarnings("all")
-@TestMetadata("analysis/analysis-api/testData/standalone/singleModule")
-@TestDataPath("$PROJECT_ROOT")
-public class StandaloneModeSingleModuleTestGenerated extends AbstractStandaloneModeSingleModuleTest {
-    @NotNull
-    @Override
-    public AnalysisApiTestConfiguratorService getConfigurator() {
-        return StandaloneModeConfiguratorService.INSTANCE;
-    }
-
-    @Test
-    public void testAllFilesPresentInSingleModule() throws Exception {
-        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/standalone/singleModule"), Pattern.compile("^(.+)\\.kt$"), null, true);
-    }
-
-    @Test
-    @TestMetadata("multipleFiles.kt")
-    public void testMultipleFiles() throws Exception {
-        runTest("analysis/analysis-api/testData/standalone/singleModule/multipleFiles.kt");
-    }
-
-    @Test
-    @TestMetadata("singleFile.kt")
-    public void testSingleFile() throws Exception {
-        runTest("analysis/analysis-api/testData/standalone/singleModule/singleFile.kt");
-    }
-
-    @Test
-    @TestMetadata("todo.kt")
-    public void testTodo() throws Exception {
-        runTest("analysis/analysis-api/testData/standalone/singleModule/todo.kt");
-    }
-}

analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/AnalysisApiTestConfiguratorService.kt

@@ -1,43 +0,0 @@
-/*
- * 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.analysis.test.framework
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestServices
-import java.nio.file.Path
-
-interface AnalysisApiTestConfiguratorService {
-    val testPrefix: String? get() = null
-
-    val analyseInDependentSession: Boolean
-
-    fun TestConfigurationBuilder.configureTest(disposable: Disposable)
-
-    fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider
-    )
-
-    fun registerApplicationServices(application: MockApplication)
-
-    fun prepareTestFiles(files: List<KtFile>, module: TestModule, testServices: TestServices) {}
-
-    fun doOutOfBlockModification(file: KtFile)
-
-    fun preprocessTestDataPath(path: Path): Path = path
-}

analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/AnalysisApiTestConfiguratorServiceFactory.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.test.framework
 
 abstract class AnalysisApiTestConfiguratorFactory {
-    abstract fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfiguratorService
+    abstract fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfigurator
 
     abstract fun supportMode(data: AnalysisApiTestConfiguratorFactoryData): Boolean
 

analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt

@@ -15,7 +15,7 @@ import junit.framework.ComparisonFailure
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyse
 import org.jetbrains.kotlin.analysis.api.analyseInDependedAnalysisSession
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestDirectives
 import org.jetbrains.kotlin.analysis.test.framework.TestWithDisposable
 import org.jetbrains.kotlin.analysis.test.framework.project.structure.KotlinProjectStructureProviderTestImpl
@@ -52,16 +52,15 @@ import kotlin.io.path.exists
 import kotlin.io.path.nameWithoutExtension
 
 abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
-    abstract val configurator: AnalysisApiTestConfiguratorService
+    abstract val configurator: AnalysisApiTestConfigurator
 
-    protected lateinit var testInfo: KotlinTestInfo
+    private lateinit var testInfo: KotlinTestInfo
         private set
 
     protected lateinit var testDataPath: Path
         private set
 
     private lateinit var moduleStructure: TestModuleStructure
-        private set
 
     protected open fun configureTest(builder: TestConfigurationBuilder) {
         with(configurator) {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/AbstractLowLevelApiSingleModuleTest.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.test.base
 
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedTest
 
 
 abstract class AbstractLowLevelApiSingleModuleTest : AbstractAnalysisApiBasedTest() {
-    override val configurator: AnalysisApiTestConfiguratorService get() = FirLowLevelAnalysisApiTestConfiguratorService
+    override val configurator: AnalysisApiTestConfigurator get() = FirLowLevelAnalysisApiTestConfigurator
 }

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/FirLowLevelAnalysisApiTestConfiguratorService.kt

@@ -1,50 +0,0 @@
-/*
- * Copyright 2010-2021 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.analysis.low.level.api.fir.test.base
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.ModuleRegistrarPreAnalysisHandler
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.registerTestServices
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalKtFile
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.bind
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-
-object FirLowLevelAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val analyseInDependentSession: Boolean get() = false
-
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        usePreAnalysisHandlers(::ModuleRegistrarPreAnalysisHandler.bind(disposable, false))
-    }
-
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        project.registerTestServices(files, packagePartProvider, projectStructureProvider)
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {}
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        ServiceManager.getService(file.project, KotlinModificationTrackerFactory::class.java)
-            .incrementModificationsCount()
-    }
-}

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesFacadeTest.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.light.classes.symbol.base
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.renderClass
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.test.model.TestModule
 import java.nio.file.Path
 
 abstract class AbstractSymbolLightClassesFacadeTest(
-    configurator: AnalysisApiTestConfiguratorService,
+    configurator: AnalysisApiTestConfigurator,
     override val currentExtension: String,
     override val stopIfCompilationErrorDirectivePresent: Boolean,
 ) : AbstractSymbolLightClassesTestBase(configurator) {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesLoadingTest.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.light.classes.symbol.base
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.SyntaxTraverser
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.renderClass
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.test.model.TestModule
 import java.nio.file.Path
 
 abstract class AbstractSymbolLightClassesLoadingTest(
-    configurator: AnalysisApiTestConfiguratorService,
+    configurator: AnalysisApiTestConfigurator,
     override val currentExtension: String,
     override val stopIfCompilationErrorDirectivePresent: Boolean,
 ) : AbstractSymbolLightClassesTestBase(configurator) {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTest.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol.base
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.asJava.LightClassTestCommon
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.psi.KtFile
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.test.model.TestModule
 import java.nio.file.Path
 
 abstract class AbstractSymbolLightClassesTest(
-    configurator: AnalysisApiTestConfiguratorService,
+    configurator: AnalysisApiTestConfigurator,
     override val currentExtension: String,
     override val stopIfCompilationErrorDirectivePresent: Boolean,
 ) : AbstractSymbolLightClassesTestBase(configurator) {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/base/AbstractSymbolLightClassesTestBase.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol.base
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiBasedSingleModuleTest
 import org.jetbrains.kotlin.analysis.test.framework.services.libraries.CompilerExecutor
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
@@ -28,7 +28,7 @@ import kotlin.io.path.exists
 import kotlin.io.path.nameWithoutExtension
 
 abstract class AbstractSymbolLightClassesTestBase(
-    override val configurator: AnalysisApiTestConfiguratorService
+    override val configurator: AnalysisApiTestConfigurator
 ) : AbstractAnalysisApiBasedSingleModuleTest() {
 
     override fun configureTest(builder: TestConfigurationBuilder) {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesFacadeForLibraryTest.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.light.classes.symbol.decompiled
 
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesFacadeTest
-import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.SymbolLightClassesForLibraryAnalysisApiTestConfigurator
 
 abstract class AbstractSymbolLightClassesFacadeForLibraryTest :
     AbstractSymbolLightClassesFacadeTest(
-        SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService,
+        SymbolLightClassesForLibraryAnalysisApiTestConfigurator,
         EXTENSIONS.LIB_JAVA,
         stopIfCompilationErrorDirectivePresent = true
     )

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesForLibraryTest.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.light.classes.symbol.decompiled
 
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesTest
-import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.SymbolLightClassesForLibraryAnalysisApiTestConfigurator
 
 abstract class AbstractSymbolLightClassesForLibraryTest :
     AbstractSymbolLightClassesTest(
-        SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService,
+        SymbolLightClassesForLibraryAnalysisApiTestConfigurator,
         EXTENSIONS.LIB_JAVA,
         stopIfCompilationErrorDirectivePresent = true
     )

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/AbstractSymbolLightClassesLoadingForLibraryTest.kt

@@ -6,11 +6,11 @@
 package org.jetbrains.kotlin.light.classes.symbol.decompiled
 
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesLoadingTest
-import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.light.classes.symbol.decompiled.service.SymbolLightClassesForLibraryAnalysisApiTestConfigurator
 
 abstract class AbstractSymbolLightClassesLoadingForLibraryTest :
     AbstractSymbolLightClassesLoadingTest(
-        SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService,
+        SymbolLightClassesForLibraryAnalysisApiTestConfigurator,
         EXTENSIONS.LIB_JAVA,
         stopIfCompilationErrorDirectivePresent = true
     )

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/service/SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService.kt

@@ -1,59 +0,0 @@
-/*
- * 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.light.classes.symbol.decompiled.service
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.fir.utils.libraries.binary.LibraryAnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.analysis.test.framework.services.libraries.CompiledLibraryProvider
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
-import org.jetbrains.kotlin.test.services.ServiceRegistrationData
-
-internal object SymbolLightClassesForLibraryAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val analyseInDependentSession: Boolean get() = false
-    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        with(LibraryAnalysisApiTestConfiguratorService) {
-            configureTest(disposable)
-        }
-        useAdditionalServices(ServiceRegistrationData(CompiledLibraryProvider::class, ::CompiledLibraryProvider))
-    }
-
-    override fun registerProjectServices(
-        project: MockProject,
-        compilerConfig: CompilerConfiguration,
-        files: List<KtFile>,
-        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-        projectStructureProvider: ProjectStructureProvider,
-        jarFileSystem: CoreJarFileSystem,
-    ) {
-        LibraryAnalysisApiTestConfiguratorService.registerProjectServices(
-            project,
-            compilerConfig,
-            files,
-            packagePartProvider,
-            projectStructureProvider,
-            jarFileSystem,
-        )
-        project.registerService(ClsJavaStubByVirtualFileCache::class.java)
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        LibraryAnalysisApiTestConfiguratorService.registerApplicationServices(application)
-    }
-
-    override fun doOutOfBlockModification(file: KtFile) {
-        LibraryAnalysisApiTestConfiguratorService.doOutOfBlockModification(file)
-    }
-}

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesFacadeForSourceTest.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.source
 
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.AnalysisApiFirTestConfigurator
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesFacadeTest
 
 abstract class AbstractSymbolLightClassesFacadeForSourceTest :
     AbstractSymbolLightClassesFacadeTest(
-        FirAnalysisApiNormalModeTestConfiguratorService,
+        AnalysisApiFirTestConfigurator(analyseInDependentSession = false),
         EXTENSIONS.FIR_JAVA,
         stopIfCompilationErrorDirectivePresent = false
     )

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesForSourceTest.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.source
 
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.AnalysisApiFirTestConfigurator
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesTest
 
 abstract class AbstractSymbolLightClassesForSourceTest :
     AbstractSymbolLightClassesTest(
-        FirAnalysisApiNormalModeTestConfiguratorService,
+        AnalysisApiFirTestConfigurator(analyseInDependentSession = false),
         EXTENSIONS.FIR_JAVA,
         stopIfCompilationErrorDirectivePresent = false
     )

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/AbstractSymbolLightClassesLoadingForSourceTest.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.source
 
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.AnalysisApiFirTestConfigurator
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesLoadingTest
 
 abstract class AbstractSymbolLightClassesLoadingForSourceTest :
     AbstractSymbolLightClassesLoadingTest(
-        FirAnalysisApiNormalModeTestConfiguratorService,
+        AnalysisApiFirTestConfigurator(analyseInDependentSession = false),
         EXTENSIONS.FIR_JAVA,
         stopIfCompilationErrorDirectivePresent = false
     )

generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/analysisApi.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.generators.tests.analysis.api
 
-import org.jetbrains.kotlin.analysis.api.fir.components.importOptimizer.AbstractHLImportOptimizerTest
-import org.jetbrains.kotlin.analysis.api.fir.components.psiTypeProvider.AbstractExpressionPsiTypeProviderTest
-import org.jetbrains.kotlin.analysis.api.fir.components.psiTypeProvider.AbstractPsiTypeProviderTest
-import org.jetbrains.kotlin.analysis.api.fir.components.typeProvider.AbstractFirGetSuperTypesTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.importOptimizer.AbstractAnalysisApiImportOptimizerTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.psiTypeProvider.AbstractAnalysisApiExpressionPsiTypeProviderTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.psiTypeProvider.AbstractAnalysisApiPsiTypeProviderTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.typeProvider.AbstractAnalysisApiGetSuperTypesTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.AbstractReferenceResolveTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnDeclarationsTest
 import org.jetbrains.kotlin.analysis.api.impl.base.test.annotations.AbstractAnalysisApiAnnotationsOnFilesTest
@@ -191,7 +191,7 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() {
 
     component("importOptimizer") {
         test(
-            AbstractHLImportOptimizerTest::class,
+            AbstractAnalysisApiImportOptimizerTest::class,
             filter = frontendIs(FrontendKind.Fir) and analysisSessionModeIs(AnalysisSessionMode.Normal),
         ) {
             model("analyseImports", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME)
@@ -199,11 +199,11 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() {
     }
 
     component("psiTypeProvider") {
-        test(AbstractPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)) {
+        test(AbstractAnalysisApiPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)) {
             model("psiType/forDeclaration")
         }
 
-        test(AbstractExpressionPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)) {
+        test(AbstractAnalysisApiExpressionPsiTypeProviderTest::class, filter = frontendIs(FrontendKind.Fir)) {
             model("psiType/forExpression")
         }
     }
@@ -240,7 +240,7 @@ private fun AnalysisApiTestGroup.generateAnalysisApiComponentsTests() {
         test(AbstractFunctionClassKindTest::class, filter = frontendIs(FrontendKind.Fir)) {
             model("functionClassKind")
         }
-        test(AbstractFirGetSuperTypesTest::class, filter = frontendIs(FrontendKind.Fir)) {
+        test(AbstractAnalysisApiGetSuperTypesTest::class, filter = frontendIs(FrontendKind.Fir)) {
             model("superTypes")
         }
         test(AbstractIsDenotableTest::class) {

generators/analysis-api-generator/tests/org/jetbrains/kotlin/generators/tests/analysis/api/dsl/FrontendConfiguratorTestGenerator.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.generators.tests.analysis.api.dsl
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorFactory
 import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorFactoryData
-import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.analysis.test.framework.FrontendKind
 import org.jetbrains.kotlin.generators.MethodGenerator
 import org.jetbrains.kotlin.generators.model.MethodModel
@@ -21,7 +21,7 @@ object FrontendConfiguratorTestGenerator : MethodGenerator<FrontendConfiguratorT
     override fun generateSignature(method: FrontendConfiguratorTestModel, p: Printer): Unit = with(p) {
         println("@NotNull")
         println("@Override")
-        print("public AnalysisApiTestConfiguratorService getConfigurator()")
+        print("public ${AnalysisApiTestConfigurator::class.simpleName} getConfigurator()")
     }
 
     override fun generateBody(method: FrontendConfiguratorTestModel, p: Printer): Unit = with(p) {
@@ -64,7 +64,7 @@ class FrontendConfiguratorTestModel(
             add(NotNull::class.java)
             add(frontendConfiguratorFactoryClass.java)
             add(AnalysisApiTestConfiguratorFactoryData::class.java)
-            add(AnalysisApiTestConfiguratorService::class.java)
+            add(AnalysisApiTestConfigurator::class.java)
             add(data.moduleKind::class.java)
 
             add(data.frontend::class.java)