[analysis api] allow generating test with for with more possible parameters

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

@@ -24,9 +24,7 @@ interface AnalysisApiTestConfiguratorService {
     val analyseInDependentSession: Boolean
 
     fun TestConfigurationBuilder.configureTest(disposable: Disposable)
-    fun processTestFiles(files: List<KtFile>): List<KtFile> = files
 
-    fun getOriginalFile(file: KtFile): KtFile = file
     fun registerProjectServices(
         project: MockProject,
         compilerConfig: CompilerConfiguration,

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

@@ -0,0 +1,51 @@
+/*
+ * 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
+
+abstract class AnalysisApiTestConfiguratorFactory {
+    abstract fun createConfigurator(data: AnalysisApiTestConfiguratorFactoryData): AnalysisApiTestConfiguratorService
+
+    abstract fun supportMode(data: AnalysisApiTestConfiguratorFactoryData): Boolean
+
+    protected fun requireSupported(data: AnalysisApiTestConfiguratorFactoryData) {
+        if (!supportMode(data)) {
+            unsupportedModeError(data)
+        }
+    }
+
+    protected fun unsupportedModeError(data: AnalysisApiTestConfiguratorFactoryData): Nothing {
+        error("${this::class} is does not support $data")
+    }
+}
+
+data class AnalysisApiTestConfiguratorFactoryData(
+    val frontend: FrontendKind,
+    val moduleKind: TestModuleKind,
+    val analysisSessionMode: AnalysisSessionMode,
+    val analysisApiMode: AnalysisApiMode,
+)
+
+enum class AnalysisSessionMode(val suffix: String) {
+    Normal("Normal"),
+
+    Dependent("Dependent");
+}
+
+enum class AnalysisApiMode(val suffix: String) {
+    Ide("Ide"),
+    Standalone("Standalone");
+}
+
+enum class FrontendKind(val suffix: String) {
+    Fir("Fir"),
+    Fe10("Fe10"),
+}
+
+enum class TestModuleKind(val suffix: String) {
+    Source("Source"),
+    LibraryBinary("LibraryBinary"),
+    LibrarySource("LibrarySource");
+}

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

@@ -0,0 +1,12 @@
+/*
+ * 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 org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer
+
+object AnalysisApiTestDirectives : SimpleDirectivesContainer() {
+    val DISABLE_DEPENDED_MODE by directive("Analysis in dependent mode should not be run in this test")
+}

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

@@ -9,12 +9,14 @@ import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.Disposer
+import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.testFramework.TestDataFile
 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.AnalysisApiTestDirectives
 import org.jetbrains.kotlin.analysis.test.framework.TestWithDisposable
 import org.jetbrains.kotlin.analysis.test.framework.project.structure.KotlinProjectStructureProviderTestImpl
 import org.jetbrains.kotlin.analysis.test.framework.project.structure.TestKtModuleProvider
@@ -58,6 +60,9 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
     protected lateinit var testDataPath: Path
         private set
 
+    private lateinit var moduleStructure: TestModuleStructure
+        private set
+
     protected open fun configureTest(builder: TestConfigurationBuilder) {
         with(configurator) {
             builder.configureTest(disposable)
@@ -122,6 +127,7 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
         useAdditionalService(::TestKtModuleProvider)
         useAdditionalService<ApplicationDisposableProvider> { ExecutionListenerBasedDisposableProvider() }
         useAdditionalService<KotlinStandardLibrariesPathProvider> { StandardLibrariesPathProviderForKotlinProject }
+        useDirectives(AnalysisApiTestDirectives)
         configureTest(this)
 
         startingArtifactFactory = { ResultingArtifact.Source() }
@@ -144,6 +150,7 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
             path,
             testConfiguration.directives,
         )
+        this.moduleStructure = moduleStructure
         val singleModule = moduleStructure.modules.single()
         val project = try {
             testServices.compilerConfigurationProvider.getProject(singleModule)
@@ -193,10 +200,12 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
     }
 
     protected fun <R> analyseForTest(contextElement: KtElement, action: KtAnalysisSession.() -> R): R {
-        return if (configurator.analyseInDependentSession) {
-            require(!contextElement.isPhysical)
-            val originalFile = configurator.getOriginalFile(contextElement.containingKtFile)
-            analyseInDependedAnalysisSession(originalFile, contextElement, action)
+        return if (configurator.analyseInDependentSession
+            && AnalysisApiTestDirectives.DISABLE_DEPENDED_MODE !in this.moduleStructure.allDirectives
+        ) {
+            val originalContainingFile = contextElement.containingKtFile
+            val fileCopy = originalContainingFile.copy() as KtFile
+            analyseInDependedAnalysisSession(originalContainingFile, PsiTreeUtil.findSameElementInCopy(contextElement, fileCopy), action)
         } else {
             analyse(contextElement, action)
         }
@@ -217,8 +226,4 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
             tags = testInfo.tags
         )
     }
-
-    companion object {
-        val DISABLE_DEPENDED_MODE_DIRECTIVE = "DISABLE_DEPENDED_MODE"
-    }
 }