[analysis api] simplify dependent analysis mode tests

2022-03-17 12:44:23 +01:00
parent 3206c0ce87
commit 12e0254918
20 changed files with 116 additions and 96 deletions
@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.generators.tests.analysis.api.dsl

 import org.jetbrains.annotations.NotNull
-import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
 import org.jetbrains.kotlin.generators.MethodGenerator
 import org.jetbrains.kotlin.generators.model.MethodModel
 import org.jetbrains.kotlin.utils.Printer
@@ -31,7 +31,7 @@ object FrontendConfiguratorTestGenerator : MethodGenerator<FrontendConfiguratorT

 object FrontendConfiguratorTestModelKind : MethodModel.Kind()

-class FrontendConfiguratorTestModel(val frontendConfiguratorClass: KClass<out FrontendApiTestConfiguratorService>) : MethodModel {
+class FrontendConfiguratorTestModel(val frontendConfiguratorClass: KClass<out AnalysisApiTestConfiguratorService>) : MethodModel {
    override val kind: MethodModel.Kind get() = FrontendConfiguratorTestModelKind
    override val name: String get() = "getConfigurator"
    override val dataString: String? get() = null
@@ -43,7 +43,7 @@ class FrontendConfiguratorTestModel(val frontendConfiguratorClass: KClass<out Fr
    override fun imports(): Collection<Class<*>> {
        return buildList {
            add(NotNull::class.java)
-            add(FrontendApiTestConfiguratorService::class.java)
+            add(AnalysisApiTestConfiguratorService::class.java)
            add(frontendConfiguratorClass.java)
        }
    }
@@ -6,18 +6,19 @@
 package org.jetbrains.kotlin.generators.tests.analysis.api.dsl

 import org.jetbrains.kotlin.analysis.api.descriptors.test.KtFe10AnalysisApiTestConfiguratorService
-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiDependentModeTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
 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.impl.barebone.test.FrontendApiTestConfiguratorService
 import org.jetbrains.kotlin.analysis.api.standalone.StandaloneModeConfiguratorService
+import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestConfiguratorService
 import org.jetbrains.kotlin.generators.TestGroup
 import org.jetbrains.kotlin.generators.TestGroupSuite
 import org.jetbrains.kotlin.generators.getDefaultSuiteTestClassName
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.capitalizeAsciiOnly
 import kotlin.reflect.KClass

-internal class FirAndFe10TestGroup(
+internal data class FirAndFe10TestGroup(
    val suite: TestGroupSuite,
    val directory: String?,
    val testModuleKinds: List<TestModuleKind>,
@@ -36,6 +37,11 @@ internal sealed class TestModuleKind(val componentName: String) {
    }
 }

+internal enum class AnalysisMode(val suffix: String) {
+    NORMAL("NormalMode"),
+    DEPENDENT("DependentMode"),
+}
+
 internal enum class Frontend(val prefix: String) {
    FIR("Fir"),
    FE10("Fe10"),
@@ -44,12 +50,14 @@ internal enum class Frontend(val prefix: String) {
 internal fun FirAndFe10TestGroup.test(
    baseClass: KClass<*>,
    generateFe10: Boolean = true,
+    analysisModesForFir: List<AnalysisMode> = listOf(AnalysisMode.NORMAL, AnalysisMode.DEPENDENT),
    init: TestGroup.TestClass.(module: TestModuleKind) -> Unit,
 ) {
    analysisApiTest(
        "analysis/analysis-api-fir/tests",
        Frontend.FIR,
        baseClass,
+        analysisModesForFir,
        init
    )
    if (generateFe10) {
@@ -57,6 +65,7 @@ internal fun FirAndFe10TestGroup.test(
            "analysis/analysis-api-fe10/tests",
            Frontend.FE10,
            baseClass,
+            listOf(AnalysisMode.NORMAL),
            init
        )
    }
@@ -66,9 +75,10 @@ internal fun TestGroupSuite.test(
    baseClass: KClass<*>,
    addFe10: Boolean = true,
    testModuleKinds: List<TestModuleKind> = TestModuleKind.SOURCE_ONLY,
+    analysisModesForFir: List<AnalysisMode> = listOf(AnalysisMode.NORMAL, AnalysisMode.DEPENDENT),
    init: TestGroup.TestClass.(module: TestModuleKind) -> Unit,
 ) {
-    FirAndFe10TestGroup(this, directory = null, testModuleKinds).test(baseClass, addFe10, init)
+    FirAndFe10TestGroup(this, directory = null, testModuleKinds).test(baseClass, addFe10, analysisModesForFir, init)
 }

 internal fun TestGroupSuite.group(
@@ -90,16 +100,15 @@ private fun FirAndFe10TestGroup.analysisApiTest(
    testRoot: String,
    frontend: Frontend,
    testClass: KClass<*>,
+    analysisModes: List<AnalysisMode>,
    init: TestGroup.TestClass.(module: TestModuleKind) -> Unit,
 ) {
    with(suite) {
        val fullTestPath = "analysis/analysis-api/testData" + directory?.let { "/$it" }.orEmpty()
        testGroup(testRoot, fullTestPath) {
-            if (testModuleKinds.size == 1) {
-                analysisApiTestClass(frontend, moduleKind = testModuleKinds.single(), testClass, prefixNeeded = false, init)
-            } else {
-                testModuleKinds.forEach { component ->
-                    analysisApiTestClass(frontend, component, testClass, prefixNeeded = true, init)
+            for (testModuleKind in testModuleKinds) {
+                for (analysisMode in analysisModes) {
+                    analysisApiTestClass(frontend, testModuleKind, analysisMode, testClass, init)
                }
            }
        }
@@ -109,8 +118,8 @@ private fun FirAndFe10TestGroup.analysisApiTest(
 private fun TestGroup.analysisApiTestClass(
    frontend: Frontend,
    moduleKind: TestModuleKind,
+    analysisMode: AnalysisMode,
    testClass: KClass<*>,
-    prefixNeeded: Boolean,
    init: TestGroup.TestClass.(module: TestModuleKind) -> Unit
 ) {
    val fullPackage = getPackageName(frontend.prefix, testClass)
@@ -118,16 +127,15 @@ private fun TestGroup.analysisApiTestClass(
    val suiteTestClassName = buildString {
        append(fullPackage)
        append(frontend.prefix)
-        moduleKind.componentName
-            .capitalizeAsciiOnly()
-            .takeIf { prefixNeeded }
-            ?.let(::append)
+        append(moduleKind.componentName.capitalizeAsciiOnly())
+        append(analysisMode.suffix)
+
        append(getDefaultSuiteTestClassName(testClass.java.simpleName))
    }

    getDefaultSuiteTestClassName(testClass.java.simpleName)

-    val configurator = createConfigurator(frontend, moduleKind)
+    val configurator = createConfigurator(frontend, moduleKind, analysisMode)

    testClass(
        testClass,
@@ -141,25 +149,56 @@ private fun TestGroup.analysisApiTestClass(

 internal fun createConfigurator(
    frontend: Frontend,
-    moduleKind: TestModuleKind
-): KClass<out FrontendApiTestConfiguratorService> = when (frontend) {
+    moduleKind: TestModuleKind,
+    analysisMode: AnalysisMode,
+): KClass<out AnalysisApiTestConfiguratorService> = when (frontend) {
    Frontend.FIR -> when (moduleKind) {
-        TestModuleKind.SOURCE -> FirAnalysisApiTestConfiguratorService::class
-        TestModuleKind.LIBRARY -> LibraryAnalysisApiTestConfiguratorService::class
-        TestModuleKind.LIBRARY_SOURCE -> LibrarySourceAnalysisApiTestConfiguratorService::class
-        TestModuleKind.STANDALONE_MODE -> StandaloneModeConfiguratorService::class
+        TestModuleKind.SOURCE -> when (analysisMode) {
+            AnalysisMode.NORMAL -> FirAnalysisApiNormalModeTestConfiguratorService::class
+            AnalysisMode.DEPENDENT -> FirAnalysisApiDependentModeTestConfiguratorService::class
+        }
+
+        TestModuleKind.LIBRARY -> {
+            checkNormalMode(frontend, moduleKind, analysisMode)
+            LibraryAnalysisApiTestConfiguratorService::class
+        }
+
+        TestModuleKind.LIBRARY_SOURCE -> {
+            checkNormalMode(frontend, moduleKind, analysisMode)
+            LibrarySourceAnalysisApiTestConfiguratorService::class
+        }
+
+        TestModuleKind.STANDALONE_MODE -> {
+            checkNormalMode(frontend, moduleKind, analysisMode)
+            StandaloneModeConfiguratorService::class
+        }
    }
+
    Frontend.FE10 -> when (moduleKind) {
-        TestModuleKind.SOURCE -> KtFe10AnalysisApiTestConfiguratorService::class
+        TestModuleKind.SOURCE -> {
+            checkNormalMode(frontend, moduleKind, analysisMode)
+            KtFe10AnalysisApiTestConfiguratorService::class
+        }
+
        TestModuleKind.LIBRARY -> TODO("TestModuleKind.LIBRARY is unsupported for fe10")
        TestModuleKind.LIBRARY_SOURCE -> TODO("TestModuleKind.LIBRARY_SOURCE is unsupported for fe10")
        TestModuleKind.STANDALONE_MODE -> TODO("TestModuleKind.STANDALONE_MODE is unsupported for fe10")
    }
 }

+private fun checkNormalMode(
+    frontend: Frontend,
+    moduleKind: TestModuleKind,
+    analysisMode: AnalysisMode
+) {
+    if (analysisMode == AnalysisMode.DEPENDENT) {
+        TODO("${AnalysisMode.DEPENDENT} is not supported for $frontend with $moduleKind")
+    }
+}
+

 private fun getPackageName(prefix: String, testClass: KClass<*>): String {
-    val basePrefix = "org.jetbrains.kotlin.analysis.api.${prefix.lowercase()}"
+    val basePrefix = "org.jetbrains.kotlin.analysis.api.${prefix.lowercase()}.test.cases"
    val packagePrefix = testClass.java.name
        .substringAfter("org.jetbrains.kotlin.analysis.api.impl.base.test.")
        .substringBeforeLast('.', "")
@@ -7,8 +7,9 @@ package org.jetbrains.kotlin.generators.tests.analysis.api

 import org.jetbrains.kotlin.generators.TestGroupSuite
 import org.jetbrains.kotlin.analysis.api.standalone.AbstractStandaloneModeSingleModuleTest
+import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.*
+import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.AnalysisMode
 import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.Frontend
-import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.FrontendConfiguratorTestModel
 import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.TestModuleKind
 import org.jetbrains.kotlin.generators.tests.analysis.api.dsl.createConfigurator

@@ -17,7 +18,7 @@ internal fun TestGroupSuite.generateStandaloneModeTests() {
        "analysis/analysis-api-standalone/tests",
        "analysis/analysis-api/testData"
    ) {
-        val configurator = createConfigurator(Frontend.FIR, TestModuleKind.STANDALONE_MODE)
+        val configurator = createConfigurator(Frontend.FIR, TestModuleKind.STANDALONE_MODE, analysisMode = AnalysisMode.NORMAL)
        testClass<AbstractStandaloneModeSingleModuleTest> {
            method(FrontendConfiguratorTestModel(configurator))
            model("standalone/singleModule")