[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
@@ -37,12 +37,11 @@ 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 val allowDependedAnalysisSession: Boolean
-        get() = false
-
    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
        usePreAnalysisHandlers(::KtFe10ModuleRegistrarPreAnalysisHandler.bind(disposable))
    }
@@ -64,7 +63,10 @@ object KtFe10AnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorSer
    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)
+            application.registerService(
+                KotlinReferenceProviderContributor::class.java,
+                KtFe10KotlinReferenceProviderContributor::class.java
+            )
        }
    }

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

-object FirAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
+open class FirAnalysisApiTestConfiguratorService(override val analyseInDependentSession: Boolean) : AnalysisApiTestConfiguratorService {
    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
        with(FirLowLevelAnalysisApiTestConfiguratorService) { configureTest(disposable) }
        configureOptionalTestCompilerPlugin()
@@ -67,3 +67,6 @@ object FirAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorServic
        FirLowLevelAnalysisApiTestConfiguratorService.doOutOfBlockModification(file)
    }
 }
+
+object FirAnalysisApiDependentModeTestConfiguratorService: FirAnalysisApiTestConfiguratorService(analyseInDependentSession = true)
+object FirAnalysisApiNormalModeTestConfiguratorService: FirAnalysisApiTestConfiguratorService(analyseInDependentSession = false)
@@ -15,7 +15,7 @@ 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.FirAnalysisApiTestConfiguratorService
+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
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

 object LibraryAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val allowDependedAnalysisSession: Boolean get() = false
+    override val analyseInDependentSession: Boolean get() = false

    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
        useConfigurators(::LibraryEnvironmentConfigurator)
@@ -50,7 +50,7 @@ object LibraryAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorSe
    }

    override fun registerApplicationServices(application: MockApplication) {
-        FirAnalysisApiTestConfiguratorService.registerApplicationServices(application)
+        FirAnalysisApiNormalModeTestConfiguratorService.registerApplicationServices(application)
        if (application.getServiceIfCreated(ClsKotlinBinaryClassCache::class.java) != null) return
        application.registerService(ClsKotlinBinaryClassCache::class.java)
        application.registerService(FileAttributeService::class.java, DummyFileAttributeService)
@@ -68,6 +68,6 @@ object LibraryAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorSe
    }

    override fun doOutOfBlockModification(file: KtFile) {
-        FirAnalysisApiTestConfiguratorService.doOutOfBlockModification(file)
+        FirAnalysisApiNormalModeTestConfiguratorService.doOutOfBlockModification(file)
    }
 }
@@ -10,7 +10,7 @@ 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.FirAnalysisApiTestConfiguratorService
+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
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.services.ServiceRegistrationData

 object LibrarySourceAnalysisApiTestConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val allowDependedAnalysisSession: Boolean get() = false
+    override val analyseInDependentSession: Boolean get() = false

    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
        useConfigurators(::LibraryEnvironmentConfigurator)
@@ -43,10 +43,10 @@ object LibrarySourceAnalysisApiTestConfiguratorService : AnalysisApiTestConfigur
    }

    override fun registerApplicationServices(application: MockApplication) {
-        FirAnalysisApiTestConfiguratorService.registerApplicationServices(application)
+        FirAnalysisApiNormalModeTestConfiguratorService.registerApplicationServices(application)
    }

    override fun doOutOfBlockModification(file: KtFile) {
-        FirAnalysisApiTestConfiguratorService.doOutOfBlockModification(file)
+        FirAnalysisApiNormalModeTestConfiguratorService.doOutOfBlockModification(file)
    }
 }
@@ -10,8 +10,8 @@ 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.api.impl.base.test.findReferencesAtCaret
 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
@@ -10,6 +10,7 @@ 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
@@ -19,11 +20,10 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

 object StandaloneModeConfiguratorService : AnalysisApiTestConfiguratorService {
-    override val allowDependedAnalysisSession: Boolean
-        get() = false
+    override val analyseInDependentSession: Boolean get() = false

    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
-        with(FirAnalysisApiTestConfiguratorService) { configureTest(disposable) }
+        with(FirAnalysisApiNormalModeTestConfiguratorService) { configureTest(disposable) }
    }

    override fun registerProjectServices(
@@ -48,6 +48,6 @@ object StandaloneModeConfiguratorService : AnalysisApiTestConfiguratorService {
    }

    override fun doOutOfBlockModification(file: KtFile) {
-        FirAnalysisApiTestConfiguratorService.doOutOfBlockModification(file)
+        FirAnalysisApiNormalModeTestConfiguratorService.doOutOfBlockModification(file)
    }
 }
@@ -20,7 +20,8 @@ import java.nio.file.Path

 interface AnalysisApiTestConfiguratorService {
    val testPrefix: String? get() = null
-    val allowDependedAnalysisSession: Boolean get() = true
+
+    val analyseInDependentSession: Boolean

    fun TestConfigurationBuilder.configureTest(disposable: Disposable)
    fun processTestFiles(files: List<KtFile>): List<KtFile> = files
@@ -35,19 +35,4 @@ abstract class AbstractAnalysisApiBasedSingleModuleTest : AbstractAnalysisApiBas

    protected inline fun <R> executeOnPooledThreadInReadAction(crossinline action: () -> R): R =
        ApplicationManager.getApplication().executeOnPooledThread<R> { runReadAction(action) }.get()
-
-    protected fun <R> analyseForTest(contextElement: KtElement, action: KtAnalysisSession.() -> R): R {
-        return if (useDependedAnalysisSession) {
-            // Depended mode does not support analysing a KtFile.
-            // See org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir#getResolveStateForDependentCopy
-            if (contextElement is KtFile) {
-                throw SkipDependedModeException()
-            }
-
-            require(!contextElement.isPhysical)
-            analyseInDependedAnalysisSession(configurator.getOriginalFile(contextElement.containingKtFile), contextElement, action)
-        } else {
-            analyse(contextElement, action)
-        }
-    }
 }
@@ -11,6 +11,9 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.Disposer
 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.TestWithDisposable
 import org.jetbrains.kotlin.analysis.test.framework.project.structure.KotlinProjectStructureProviderTestImpl
@@ -22,6 +25,7 @@ import org.jetbrains.kotlin.analysis.test.framework.project.structure.getKtFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.ExecutionListenerBasedDisposableProvider
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
@@ -42,21 +46,15 @@ import org.junit.jupiter.api.TestInfo
 import java.io.File
 import java.nio.file.Path
 import java.nio.file.Paths
-import java.util.concurrent.ExecutionException
 import kotlin.io.path.exists
 import kotlin.io.path.nameWithoutExtension

 abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
    abstract val configurator: AnalysisApiTestConfiguratorService

-    protected open val enableTestInDependedMode: Boolean
-        get() = configurator.allowDependedAnalysisSession
-
    protected lateinit var testInfo: KotlinTestInfo
        private set

-    protected var useDependedAnalysisSession: Boolean = false
-
    protected lateinit var testDataPath: Path
        private set

@@ -192,21 +190,15 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {

        configurator.prepareTestFiles(ktFiles, singleModule, testServices)
        doTestByFileStructure(ktFiles, moduleStructure, testServices)
-        if (!enableTestInDependedMode || ktFiles.any {
-                InTextDirectivesUtils.isDirectiveDefined(it.text, DISABLE_DEPENDED_MODE_DIRECTIVE)
-            }) {
-            return
-        }
-        try {
-            useDependedAnalysisSession = true
-            doTestByFileStructure(configurator.processTestFiles(ktFiles), moduleStructure, testServices)
-        } catch (e: SkipDependedModeException) {
-            // Skip the test if needed
-        } catch (e: ExecutionException) {
-            if (e.cause !is SkipDependedModeException)
-                throw Exception("Test succeeded in normal analysis mode but failed in depended analysis mode.", e)
-        } catch (e: Exception) {
-            throw Exception("Test succeeded in normal analysis mode but failed in depended analysis mode.", e)
+    }
+
+    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)
+        } else {
+            analyse(contextElement, action)
        }
    }

@@ -226,8 +218,6 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
        )
    }

-    protected class SkipDependedModeException : Exception()
-
    companion object {
        val DISABLE_DEPENDED_MODE_DIRECTIVE = "DISABLE_DEPENDED_MODE"
    }
@@ -78,8 +78,6 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
        testServices.assertions.assertEqualsToTestDataFileSibling(resultBuilder.toString())
    }

-    override val enableTestInDependedMode: Boolean = false
-
    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)
        with(builder) {
@@ -40,5 +40,5 @@ abstract class AbstractFirOnAirResolveTest : AbstractLowLevelApiSingleFileTest()
        }
    }

-    override val enableTestInDependedMode: Boolean get() = false
+//    override val enableTestInDependedMode: Boolean get() = false
 }
@@ -24,6 +24,8 @@ 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))
    }
@@ -31,8 +31,6 @@ abstract class AbstractSymbolLightClassesTestBase(
    override val configurator: AnalysisApiTestConfiguratorService
 ) : AbstractAnalysisApiBasedSingleModuleTest() {

-    override val enableTestInDependedMode: Boolean get() = false
-
    override fun configureTest(builder: TestConfigurationBuilder) {
        super.configureTest(builder)
        with(builder) {
@@ -22,6 +22,7 @@ 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)
@@ -5,12 +5,12 @@

 package org.jetbrains.kotlin.light.classes.symbol.source

-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesFacadeTest

 abstract class AbstractSymbolLightClassesFacadeForSourceTest :
    AbstractSymbolLightClassesFacadeTest(
-        FirAnalysisApiTestConfiguratorService,
+        FirAnalysisApiNormalModeTestConfiguratorService,
        EXTENSIONS.FIR_JAVA,
        stopIfCompilationErrorDirectivePresent = false
    )
@@ -5,12 +5,12 @@

 package org.jetbrains.kotlin.light.classes.symbol.source

-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesTest

 abstract class AbstractSymbolLightClassesForSourceTest :
    AbstractSymbolLightClassesTest(
-        FirAnalysisApiTestConfiguratorService,
+        FirAnalysisApiNormalModeTestConfiguratorService,
        EXTENSIONS.FIR_JAVA,
        stopIfCompilationErrorDirectivePresent = false
    )
@@ -5,12 +5,12 @@

 package org.jetbrains.kotlin.light.classes.symbol.source

-import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirAnalysisApiNormalModeTestConfiguratorService
 import org.jetbrains.kotlin.light.classes.symbol.base.AbstractSymbolLightClassesLoadingTest

 abstract class AbstractSymbolLightClassesLoadingForSourceTest :
    AbstractSymbolLightClassesLoadingTest(
-        FirAnalysisApiTestConfiguratorService,
+        FirAnalysisApiNormalModeTestConfiguratorService,
        EXTENSIONS.FIR_JAVA,
        stopIfCompilationErrorDirectivePresent = false
    )