[FIR IDE] Extract common components of the Analysis API to separate modules

.idea/dictionaries/yan.xml

@@ -1,6 +1,7 @@
 <component name="ProjectDictionaryState">
   <dictionary name="yan">
     <words>
+      <w>barebone</w>
       <w>debuggee</w>
       <w>deserializes</w>
       <w>destructured</w>

analysis/analysis-api-fir/build.gradle.kts

@@ -16,6 +16,7 @@ dependencies {
     api(project(":compiler:fir:java"))
     api(project(":analysis:low-level-api-fir"))
     api(project(":analysis:analysis-api"))
+    api(project(":analysis:analysis-api-impl-base"))
     api(project(":compiler:light-classes"))
     api(intellijCoreDep())
     implementation(project(":analysis:analysis-api-providers"))
@@ -26,6 +27,7 @@ dependencies {
     testApi(projectTests(":compiler:test-infrastructure"))
     testApi(projectTests(":compiler:tests-common-new"))
     testApi(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testApi(projectTests(":analysis:analysis-api-impl-base"))
     testApi(project(":kotlin-test:kotlin-test-junit"))
     testApi(toolsJar())
     testApiJUnit5()

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt

@@ -6,73 +6,33 @@
 package org.jetbrains.kotlin.analysis.api.fir
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.ProjectRootModificationTracker
+import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
-import com.intellij.psi.util.CachedValueProvider
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import com.intellij.psi.util.CachedValuesManager
-import com.intellij.psi.util.PsiModificationTracker
-import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
-import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
-import org.jetbrains.kotlin.analysis.api.*
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
+import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
-import org.jetbrains.kotlin.analysis.api.tokens.ValidityTokenFactory
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
+import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
 import org.jetbrains.kotlin.psi.KtElement
-import java.util.concurrent.ConcurrentHashMap
-import kotlin.reflect.KClass
 
 @OptIn(InvalidWayOfUsingAnalysisSession::class)
-class KtFirAnalysisSessionProvider(private val project: Project) : KtAnalysisSessionProvider() {
+class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<FirModuleResolveState>(project) {
-    private val cache = KtAnalysisSessionCache<Pair<FirModuleResolveState, KClass<out ValidityToken>>>(project)
+    override fun getResolveState(contextElement: KtElement): FirModuleResolveState {
-
+        return contextElement.getResolveState()
-    @InvalidWayOfUsingAnalysisSession
-    override fun getAnalysisSession(contextElement: KtElement, factory: ValidityTokenFactory): KtAnalysisSession {
-        val resolveState = contextElement.getResolveState()
-        return cache.getAnalysisSession(resolveState to factory.identifier) {
-            val validityToken = factory.create(project)
-            @Suppress("DEPRECATION")
-            KtFirAnalysisSession.createAnalysisSessionByResolveState(resolveState, validityToken, contextElement)
-        }
     }
 
-    override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession {
+    override fun getResolveState(contextSymbol: KtSymbol): FirModuleResolveState {
         require(contextSymbol is KtFirSymbol<*>)
-        val resolveState = contextSymbol.firRef.resolveState
+        return contextSymbol.firRef.resolveState
-        val token = contextSymbol.token
-        return getCachedAnalysisSession(resolveState, token)
-            ?: error("analysis session was not found for ${contextSymbol::class}, symbol.isValid=${contextSymbol.isValid()}")
     }
 
-    private fun getCachedAnalysisSession(resolveState: FirModuleResolveState, token: ValidityToken): KtAnalysisSession? {
+    override fun createAnalysisSession(
-        return cache.getCachedAnalysisSession(resolveState to token::class)
+        resolveState: FirModuleResolveState,
+        validityToken: ValidityToken,
+        contextElement: KtElement
+    ): KtAnalysisSession {
+        @Suppress("DEPRECATION")
+        return KtFirAnalysisSession.createAnalysisSessionByResolveState(resolveState, validityToken, contextElement)
     }
-
-    @TestOnly
-    override fun clearCaches() {
-        cache.clear()
-    }
-}
-
-private class KtAnalysisSessionCache<KEY : Any>(project: Project) {
-    private val cache = CachedValuesManager.getManager(project).createCachedValue {
-        CachedValueProvider.Result(
-            ConcurrentHashMap<KEY, KtAnalysisSession>(),
-            PsiModificationTracker.MODIFICATION_COUNT,
-            ProjectRootModificationTracker.getInstance(project),
-            project.createProjectWideOutOfBlockModificationTracker()
-        )
-    }
-
-    @TestOnly
-    fun clear() {
-        cache.value.clear()
-    }
-
-    inline fun getAnalysisSession(key: KEY, create: () -> KtAnalysisSession): KtAnalysisSession =
-        cache.value.getOrPut(key) { create() }
-
-    fun getCachedAnalysisSession(key: KEY): KtAnalysisSession? =
-        cache.value[key]
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt

@@ -38,6 +38,8 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
+import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirClassInitializerSymbol
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.types.Variance
@@ -390,7 +392,10 @@ internal class KtSymbolByFirBuilder private constructor(
 
         fun buildSubstitutor(substitutor: ConeSubstitutor): KtSubstitutor {
             if (substitutor == ConeSubstitutor.Empty) return KtSubstitutor.Empty(token)
-            return KtFirSubstitutor(substitutor, this@KtSymbolByFirBuilder, token)
+            return when (substitutor) {
+                is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(substitutor, this@KtSymbolByFirBuilder, token)
+                else -> KtFirGenericSubstitutor(substitutor, this@KtSymbolByFirBuilder, token)
+            }
         }
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeF
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentsOfType
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
@@ -55,10 +54,8 @@ import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
-import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
-import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.*
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.parentOrNull
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelector

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt

@@ -10,12 +10,12 @@ import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.FirRealSourceElementKind
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentOfType
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolContainingDeclarationProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt

@@ -13,11 +13,11 @@ import org.jetbrains.kotlin.fir.resolve.calls.ExpressionReceiverValue
 import org.jetbrains.kotlin.fir.visibilityChecker
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirSafe
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentsOfType
 import org.jetbrains.kotlin.analysis.api.components.KtVisibilityChecker
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirReferenceResolver.kt

@@ -13,7 +13,7 @@ import com.intellij.psi.impl.source.resolve.ResolveCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.analysis.api.tokens.HackToForceAllowRunningAnalyzeOnEDT
 import org.jetbrains.kotlin.analysis.api.analyse
-import org.jetbrains.kotlin.analysis.api.fir.utils.runInPossiblyEdtThread
+import org.jetbrains.kotlin.analysis.api.impl.base.util.runInPossiblyEdtThread
 
 object KtFirReferenceResolver : ResolveCache.PolyVariantResolver<KtReference> {
     class KotlinResolveResult(element: PsiElement) : PsiElementResolveResult(element)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/renderer/FirIdeRenderer.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.components.RendererModifier
 import org.jetbrains.kotlin.analysis.api.fir.types.PublicTypeApproximator
+import org.jetbrains.kotlin.fir.analysis.checkers.PsiSourceNavigator.getRawName
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.renderer.render
@@ -405,7 +406,7 @@ internal class FirIdeRenderer private constructor(
                 visitEnumEntry(enumEntry, data)
                 data.append(",")
             }
-            partitioned.second.forEach {
+            sortDeclarations(partitioned.second).forEach {
                 if (!it.skipDeclarationForEnumClass()) {
                     it.accept(this, data)
                 }
@@ -414,7 +415,7 @@ internal class FirIdeRenderer private constructor(
 
         fun renderDeclarationForNotEnumClass() {
             check(!regularClass.isEnumClass)
-            regularClass.declarations.forEach {
+            sortDeclarations(regularClass.declarations).forEach {
                 if (!it.isDefaultPrimaryConstructor()) {
                     it.accept(this, data)
                 }
@@ -679,6 +680,33 @@ internal class FirIdeRenderer private constructor(
         supertypes.joinTo(this, ", ") { renderType(it) }
     }
 
+    fun sortDeclarations(declarations: List<FirDeclaration>): List<FirDeclaration> {
+        if (!options.sortNestedDeclarations) return declarations
+
+        fun getDeclarationKind(declaration: FirDeclaration): Int = when (declaration) {
+            is FirEnumEntry -> 0
+            is FirConstructor -> if (declaration.isPrimary) 1 else 2
+            is FirProperty -> 3
+            is FirFunction -> 4
+            else -> 5
+        }
+
+        return declarations.sortedWith(Comparator { left, right ->
+            val kindResult = getDeclarationKind(left) - getDeclarationKind(right)
+            if (kindResult != 0) {
+                return@Comparator kindResult
+            }
+
+            val nameResult = (left.getRawName() ?: "").compareTo(right.getRawName() ?: "")
+            if (nameResult != 0) {
+                return@Comparator nameResult
+            }
+
+            val leftString = StringBuilder().also { builder -> left.accept(this, builder) }.toString()
+            val rightString = StringBuilder().also { builder -> right.accept(this, builder) }.toString()
+            return@Comparator leftString.compareTo(rightString)
+        })
+    }
 
     private fun getClassifierKindPrefix(classifier: FirDeclaration): String = when (classifier) {
         is FirTypeAlias -> "typealias"

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/types/KtFirSubstitutor.kt

@@ -7,22 +7,49 @@ package org.jetbrains.kotlin.analysis.api.fir.types
 
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
+import org.jetbrains.kotlin.analysis.api.impl.base.KtMapBackedSubstitutor
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
+import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 
-internal class KtFirSubstitutor(
+internal abstract class AbstractKtFirSubstitutor<T : ConeSubstitutor>(
-    private val _substitutor: ConeSubstitutor,
+    private val _substitutor: T,
     builder: KtSymbolByFirBuilder,
     override val token: ValidityToken,
 ) : KtSubstitutor {
-    private val builderRef by weakRef(builder)
+    protected val builderRef by weakRef(builder)
-    val substitutor: ConeSubstitutor get() = withValidityAssertion { _substitutor }
+    val substitutor: T get() = withValidityAssertion { _substitutor }
 
     override fun substituteOrNull(type: KtType): KtType? = withValidityAssertion {
         require(type is KtFirType)
         substitutor.substituteOrNull(type.coneType)?.type?.let { builderRef.typeBuilder.buildKtType(it) }
     }
+}
+
+internal class KtFirGenericSubstitutor(
+    _substitutor: ConeSubstitutor,
+    builder: KtSymbolByFirBuilder,
+    token: ValidityToken
+) : AbstractKtFirSubstitutor<ConeSubstitutor>(_substitutor, builder, token)
+
+internal class KtFirMapBackedSubstitutor(
+    _substitutor: ConeSubstitutorByMap,
+    builder: KtSymbolByFirBuilder,
+    token: ValidityToken
+) : AbstractKtFirSubstitutor<ConeSubstitutorByMap>(_substitutor, builder, token), KtMapBackedSubstitutor {
+    override fun getAsMap(): Map<KtTypeParameterSymbol, KtType> {
+        val result = mutableMapOf<KtTypeParameterSymbol, KtType>()
+        for ((typeParameter, type) in substitutor.substitution) {
+            val typeParameterSymbol = builderRef.classifierBuilder.buildTypeParameterSymbolByLookupTag(typeParameter.toLookupTag())
+            if (typeParameterSymbol != null) {
+                result[typeParameterSymbol] = builderRef.typeBuilder.buildKtType(type)
+            }
+        }
+
+        return result
+    }
 }

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

@@ -0,0 +1,14 @@
+/*
+ * 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 org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.AbstractReferenceResolveTest
+
+abstract class AbstractFirReferenceResolveTest : AbstractReferenceResolveTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,48 @@
+/*
+ * 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 org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService
+import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.FirLowLevelFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.idea.references.KotlinFirReferenceContributor
+import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
+import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+
+object FirFrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService {
+    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
+        with(FirLowLevelFrontendApiTestConfiguratorService) { configureTest(disposable) }
+    }
+
+    override fun processTestFiles(files: List<KtFile>): List<KtFile> {
+        return FirLowLevelFrontendApiTestConfiguratorService.processTestFiles(files)
+    }
+
+    override fun getOriginalFile(file: KtFile): KtFile {
+        return FirLowLevelFrontendApiTestConfiguratorService.getOriginalFile(file)
+    }
+
+    @OptIn(InvalidWayOfUsingAnalysisSession::class)
+    override fun registerProjectServices(project: MockProject) {
+        FirLowLevelFrontendApiTestConfiguratorService.registerProjectServices(project)
+        project.registerService(KtAnalysisSessionProvider::class.java, KtFirAnalysisSessionProvider::class.java)
+    }
+
+    override fun registerApplicationServices(application: MockApplication) {
+        FirLowLevelFrontendApiTestConfiguratorService.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)
+        }
+    }
+}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/FirReferenceResolveTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/referenceResolve")
 @TestDataPath("$PROJECT_ROOT")
-public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest {
+public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolveTest {
     @Test
     public void testAllFilesPresentInReferenceResolve() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/referenceResolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true);

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

@@ -0,0 +1,17 @@
+/*
+ * 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.openapi.components.ServiceManager
+import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
+import org.jetbrains.kotlin.psi.KtFile
+
+object FirTestWithOutOfBlockModification {
+    fun doOutOfBlockModification(ktFile: KtFile) {
+        ServiceManager.getService(ktFile.project, KotlinModificationTrackerFactory::class.java)
+            .incrementModificationsCount()
+    }
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractCompileTimeConstantEvaluatorTest
+
+abstract class AbstractFirCompileTimeConstantEvaluatorTest : AbstractCompileTimeConstantEvaluatorTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractExpectedExpressionTypeTest
+
+abstract class AbstractFirExpectedExpressionTypeTest : AbstractExpectedExpressionTypeTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -7,15 +7,20 @@ package org.jetbrains.kotlin.analysis.api.fir.components
 
 import org.jetbrains.kotlin.analysis.api.analyse
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
 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 AbstractGetSuperTypesTest : AbstractHLApiSingleFileTest() {
+abstract class AbstractFirGetSuperTypesTest : AbstractHLApiSingleFileTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
         val expression = testServices.expressionMarkerProvider.getSelectedElement(ktFile)
 

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractHLExpressionTypeTest
+
+abstract class AbstractFirHLExpressionTypeTest : AbstractHLExpressionTypeTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractHasCommonSubtypeTest
+
+abstract class AbstractFirHasCommonSubtypeTest : AbstractHasCommonSubtypeTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractOverriddenDeclarationProviderTest
+
+abstract class AbstractFirOverriddenDeclarationProviderTest : AbstractOverriddenDeclarationProviderTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.components.AbstractRendererTest
+
+abstract class AbstractFirRendererTest : AbstractRendererTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.fir.AbstractResolveCallTest
+
+abstract class AbstractFirResolveCallTest : AbstractResolveCallTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

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

@@ -5,13 +5,18 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.components
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleModuleTest
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleModuleTest
 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 : AbstractHLApiSingleModuleTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+
     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 }

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirCompileTimeConstantEvaluatorTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/compileTimeConstantEvaluator")
 @TestDataPath("$PROJECT_ROOT")
-public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTimeConstantEvaluatorTest {
+public class FirCompileTimeConstantEvaluatorTestGenerated extends AbstractFirCompileTimeConstantEvaluatorTest {
     @Test
     public void testAllFilesPresentInCompileTimeConstantEvaluator() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/compileTimeConstantEvaluator"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirExpectedExpressionTypeTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/expectedExpressionType")
 @TestDataPath("$PROJECT_ROOT")
-public class ExpectedExpressionTypeTestGenerated extends AbstractExpectedExpressionTypeTest {
+public class FirExpectedExpressionTypeTestGenerated extends AbstractFirExpectedExpressionTypeTest {
     @Test
     public void testAllFilesPresentInExpectedExpressionType() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirGetSuperTypesTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/getSuperTypes")
 @TestDataPath("$PROJECT_ROOT")
-public class GetSuperTypesTestGenerated extends AbstractGetSuperTypesTest {
+public class FirGetSuperTypesTestGenerated extends AbstractFirGetSuperTypesTest {
     @Test
     public void testAllFilesPresentInGetSuperTypes() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/getSuperTypes"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirHLExpressionTypeTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/expressionType")
 @TestDataPath("$PROJECT_ROOT")
-public class HLExpressionTypeTestGenerated extends AbstractHLExpressionTypeTest {
+public class FirHLExpressionTypeTestGenerated extends AbstractFirHLExpressionTypeTest {
     @Test
     public void testAllFilesPresentInExpressionType() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/expressionType"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirHasCommonSubtypeTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/hasCommonSubtype")
 @TestDataPath("$PROJECT_ROOT")
-public class HasCommonSubtypeTestGenerated extends AbstractHasCommonSubtypeTest {
+public class FirHasCommonSubtypeTestGenerated extends AbstractFirHasCommonSubtypeTest {
     @Test
     public void testAllFilesPresentInHasCommonSubtype() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/hasCommonSubtype"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirOverriddenDeclarationProviderTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/overridenDeclarations")
 @TestDataPath("$PROJECT_ROOT")
-public class OverriddenDeclarationProviderTestGenerated extends AbstractOverriddenDeclarationProviderTest {
+public class FirOverriddenDeclarationProviderTestGenerated extends AbstractFirOverriddenDeclarationProviderTest {
     @Test
     public void testAllFilesPresentInOverridenDeclarations() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/overridenDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirRendererTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/components/declarationRenderer")
 @TestDataPath("$PROJECT_ROOT")
-public class RendererTestGenerated extends AbstractRendererTest {
+public class FirRendererTestGenerated extends AbstractFirRendererTest {
     @Test
     public void testAllFilesPresentInDeclarationRenderer() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/declarationRenderer"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/components/FirResolveCallTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/analysisSession/resolveCall")
 @TestDataPath("$PROJECT_ROOT")
-public class ResolveCallTestGenerated extends AbstractResolveCallTest {
+public class FirResolveCallTestGenerated extends AbstractFirResolveCallTest {
     @Test
     public void testAllFilesPresentInResolveCall() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/analysisSession/resolveCall"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/scopes/AbstractFirFileScopeTest.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.scopes
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractFileScopeTest
+
+abstract class AbstractFirFileScopeTest : AbstractFileScopeTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/scopes/AbstractFirMemberScopeByFqNameTest.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.scopes
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirTestWithOutOfBlockModification
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.scopes.AbstractMemberScopeByFqNameTest
+import org.jetbrains.kotlin.psi.KtFile
+
+abstract class AbstractFirMemberScopeByFqNameTest : AbstractMemberScopeByFqNameTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+
+    override fun doOutOfBlockModification(ktFile: KtFile) {
+        FirTestWithOutOfBlockModification.doOutOfBlockModification(ktFile)
+    }
+}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/scopes/FirFileScopeTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/fileScopeTest")
 @TestDataPath("$PROJECT_ROOT")
-public class FileScopeTestGenerated extends AbstractFileScopeTest {
+public class FirFileScopeTestGenerated extends AbstractFirFileScopeTest {
     @Test
     public void testAllFilesPresentInFileScopeTest() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/fileScopeTest"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/scopes/FirMemberScopeByFqNameTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/memberScopeByFqName")
 @TestDataPath("$PROJECT_ROOT")
-public class MemberScopeByFqNameTestGenerated extends AbstractMemberScopeByFqNameTest {
+public class FirMemberScopeByFqNameTestGenerated extends AbstractFirMemberScopeByFqNameTest {
     @Test
     public void testAllFilesPresentInMemberScopeByFqName() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/memberScopeByFqName"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/symbols/AbstractFirSymbolByFqNameTest.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.symbols
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirTestWithOutOfBlockModification
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByFqNameTest
+import org.jetbrains.kotlin.psi.KtFile
+
+abstract class AbstractFirSymbolByFqNameTest : AbstractSymbolByFqNameTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+
+    override fun doOutOfBlockModification(ktFile: KtFile) {
+        FirTestWithOutOfBlockModification.doOutOfBlockModification(ktFile)
+    }
+}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/symbols/AbstractFirSymbolByPsiTest.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.symbols
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirTestWithOutOfBlockModification
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByPsiTest
+import org.jetbrains.kotlin.psi.KtFile
+
+abstract class AbstractFirSymbolByPsiTest : AbstractSymbolByPsiTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+
+    override fun doOutOfBlockModification(ktFile: KtFile) {
+        FirTestWithOutOfBlockModification.doOutOfBlockModification(ktFile)
+    }
+}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/symbols/AbstractFirSymbolByReferenceTest.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.symbols
+
+import org.jetbrains.kotlin.analysis.api.fir.FirFrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.fir.FirTestWithOutOfBlockModification
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByReferenceTest
+import org.jetbrains.kotlin.psi.KtFile
+
+abstract class AbstractFirSymbolByReferenceTest : AbstractSymbolByReferenceTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirFrontendApiTestConfiguratorService
+
+    override fun doOutOfBlockModification(ktFile: KtFile) {
+        FirTestWithOutOfBlockModification.doOutOfBlockModification(ktFile)
+    }
+}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/symbols/FirSymbolByFqNameTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/symbols/symbolByFqName")
 @TestDataPath("$PROJECT_ROOT")
-public class SymbolByFqNameTestGenerated extends AbstractSymbolByFqNameTest {
+public class FirSymbolByFqNameTestGenerated extends AbstractFirSymbolByFqNameTest {
     @Test
     public void testAllFilesPresentInSymbolByFqName() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByFqName"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/symbols/FirSymbolByPsiTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/symbols/symbolByPsi")
 @TestDataPath("$PROJECT_ROOT")
-public class SymbolByPsiTestGenerated extends AbstractSymbolByPsiTest {
+public class FirSymbolByPsiTestGenerated extends AbstractFirSymbolByPsiTest {
     @Test
     public void testAllFilesPresentInSymbolByPsi() throws Exception {
         KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/symbolByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true);

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/symbols/FirSymbolByReferenceTestGenerated.java

@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @TestMetadata("analysis/analysis-api/testData/symbols/symbolByReference")
 @TestDataPath("$PROJECT_ROOT")
-public class SymbolByReferenceTestGenerated extends AbstractSymbolByReferenceTest {
+public class FirSymbolByReferenceTestGenerated extends AbstractFirSymbolByReferenceTest {
     @Test
     @TestMetadata("accessorField.kt")
     public void testAccessorField() throws Exception {

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/test/framework/AbstractHLApiSingleModuleTest.kt

@@ -1,20 +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.test.framework
-
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.model.TestModule
-import org.jetbrains.kotlin.test.services.TestModuleStructure
-import org.jetbrains.kotlin.test.services.TestServices
-
-abstract class AbstractHLApiSingleModuleTest : AbstractHLApiTest() {
-    final override fun doTestByFileStructure(ktFiles: List<KtFile>, moduleStructure: TestModuleStructure, testServices: TestServices) {
-        val singleModule = moduleStructure.modules.single()
-        doTestByFileStructure(ktFiles, singleModule, testServices)
-    }
-
-    protected abstract fun doTestByFileStructure(ktFiles: List<KtFile>, module: TestModule, testServices: TestServices)
-}

analysis/analysis-api-fir/tests/org/jetbrains/kotlin/analysis/api/fir/test/framework/AbstractHLApiTest.kt

@@ -1,32 +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.test.framework
-
-import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiTest
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
-import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
-import org.jetbrains.kotlin.idea.references.HLApiReferenceProviderService
-import org.jetbrains.kotlin.idea.references.KotlinFirReferenceContributor
-import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
-import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
-
-abstract class AbstractHLApiTest : AbstractLowLevelApiTest() {
-    @OptIn(InvalidWayOfUsingAnalysisSession::class)
-    override fun registerServicesForProject(project: MockProject) {
-        super.registerServicesForProject(project)
-        project.registerService(KtAnalysisSessionProvider::class.java, KtFirAnalysisSessionProvider::class.java)
-    }
-
-    override fun registerApplicationServices(application: MockApplication) {
-        super.registerApplicationServices(application)
-        if (application.getServiceIfCreated(KotlinReferenceProvidersService::class.java) != null) return
-        application.registerService(KotlinReferenceProvidersService::class.java, HLApiReferenceProviderService::class.java)
-        application.registerService(KotlinReferenceProviderContributor::class.java, KotlinFirReferenceContributor::class.java)
-    }
-}

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

@@ -1,30 +0,0 @@
-/*
- * Copyright 2010-2020 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 org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.DuplicatedFirSourceElementsException
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
-
-/**
- * Temporary
- * @see org.jetbrains.kotlin.analysis.low.level.api.fir.DuplicatedFirSourceElementsException.IS_ENABLED
- */
-inline fun <T> withPossiblyDisabledDuplicatedFirSourceElementsException(fileText: String, action: () -> T): T {
-    val isDisabled = InTextDirectivesUtils.isDirectiveDefined(fileText, "IGNORE_DUPLICATED_FIR_SOURCE_EXCEPTION")
-
-    @Suppress("LiftReturnOrAssignment")
-    if (isDisabled) {
-        val wasEnabled = DuplicatedFirSourceElementsException.IS_ENABLED
-        DuplicatedFirSourceElementsException.IS_ENABLED = false
-        try {
-            return action()
-        } finally {
-            DuplicatedFirSourceElementsException.IS_ENABLED = wasEnabled
-        }
-    } else {
-        return action()
-    }
-}

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

@@ -0,0 +1,25 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    api(project(":compiler:psi"))
+    api(project(":analysis:analysis-api-providers"))
+    api(project(":analysis:project-structure"))
+    api(intellijCoreDep()) { includeJars("intellij-core", rootProject = rootProject) }
+
+    testApiJUnit5()
+    testApi(project(":kotlin-test:kotlin-test-junit"))
+    testApi(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:test-infrastructure"))
+    testApi(projectTests(":compiler:tests-common-new"))
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" { projectDefault() }
+}
+
+testsJar()

analysis/analysis-api-impl-barebone/src/org/jetbrains/kotlin/analysis/api/impl/barebone/annotations/annotations.kt

@@ -3,7 +3,7 @@
  * 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.annotations
+package org.jetbrains.kotlin.analysis.api.impl.barebone.annotations
 
 @RequiresOptIn
 annotation class PrivateForInline

analysis/analysis-api-impl-barebone/src/org/jetbrains/kotlin/analysis/api/impl/barebone/annotations/threads.kt

@@ -1,9 +1,9 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.annotations
+package org.jetbrains.kotlin.analysis.api.impl.barebone.annotations
 
 @Target(AnnotationTarget.CLASS)
 annotation class ThreadSafe

analysis/analysis-api-impl-barebone/src/org/jetbrains/kotlin/analysis/api/impl/barebone/psiUtils.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.impl.barebone
+
+import com.intellij.psi.PsiElement
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.psi.psiUtil.parents
+import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
+
+inline fun <reified T : PsiElement> PsiElement.parentOfType(withSelf: Boolean = false): T? {
+    return PsiTreeUtil.getParentOfType(this, T::class.java, !withSelf)
+}
+
+fun <T : PsiElement> PsiElement.parentsOfType(clazz: Class<out T>, withSelf: Boolean = true): Sequence<T> {
+    return (if (withSelf) parentsWithSelf else parents).filterIsInstance(clazz)
+}
+
+inline fun <reified T : PsiElement> PsiElement.parentsOfType(withSelf: Boolean = true): Sequence<T> =
+    parentsOfType(T::class.java, withSelf)

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractCompilerBasedTest.kt

@@ -0,0 +1,41 @@
+/*
+ * 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.impl.barebone.test
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.util.Disposer
+import org.jetbrains.kotlin.test.TestConfiguration
+import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
+import org.jetbrains.kotlin.test.services.isKtFile
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.TestInfo
+
+abstract class AbstractCompilerBasedTest : AbstractKotlinCompilerTest() {
+    private var _disposable: Disposable? = null
+    protected val disposable: Disposable get() = _disposable!!
+
+    @BeforeEach
+    private fun intiDisposable(testInfo: TestInfo) {
+        _disposable = Disposer.newDisposable("disposable for ${testInfo.displayName}")
+    }
+
+    @AfterEach
+    private fun disposeDisposable() {
+        _disposable?.let { Disposer.dispose(it) }
+        _disposable = null
+    }
+
+    protected fun ignoreTest(filePath: String, configuration: TestConfiguration): Boolean {
+        val modules = configuration.moduleStructureExtractor.splitTestDataByModules(filePath, configuration.directives)
+
+        if (modules.modules.none { it.files.any { it.isKtFile } }) {
+            return true // nothing to highlight
+        }
+
+        return false
+    }
+}

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/AbstractFrontendApiTest.kt

@@ -3,28 +3,19 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.barebone.test
 
 import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.util.Computable
 import com.intellij.openapi.util.Disposer
 import com.intellij.testFramework.TestDataFile
-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.low.level.api.fir.compiler.based.ModuleRegistrarPreAnalysisHandler
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.TestKtModuleProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.projectModuleProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalKtFile
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
-import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.testConfiguration
 import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives
@@ -40,13 +31,58 @@ import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.TestInfo
 import java.nio.file.Path
 import java.nio.file.Paths
+import kotlin.io.path.exists
 import java.util.concurrent.ExecutionException
 import kotlin.io.path.nameWithoutExtension
 
-abstract class AbstractLowLevelApiTest : TestWithDisposable() {
+interface FrontendApiTestConfiguratorService {
-    private lateinit var testInfo: KotlinTestInfo
+    fun TestConfigurationBuilder.configureTest(disposable: Disposable)
-    private var useDependedAnalysisSession: Boolean = false
+
-    open protected val enableTestInDependedMode: Boolean = true
+    fun processTestFiles(files: List<KtFile>): List<KtFile> = files
+    fun getOriginalFile(file: KtFile): KtFile = file
+
+    fun registerProjectServices(project: MockProject)
+    fun registerApplicationServices(application: MockApplication)
+}
+
+abstract class AbstractFrontendApiTest : TestWithDisposable() {
+    protected open val enableTestInDependedMode: Boolean = true
+
+    protected lateinit var testInfo: KotlinTestInfo
+        private set
+
+    protected var useDependedAnalysisSession: Boolean = false
+
+    protected lateinit var testDataPath: Path
+        private set
+
+    protected abstract val configurator: FrontendApiTestConfiguratorService
+
+    protected open val testPrefix: String?
+        get() = null
+
+    protected open fun configureTest(builder: TestConfigurationBuilder) {
+        with(configurator) {
+            builder.configureTest(disposable)
+        }
+    }
+
+    protected abstract fun doTestByFileStructure(ktFiles: List<KtFile>, moduleStructure: TestModuleStructure, testServices: TestServices)
+
+    protected fun testDataFileSibling(extension: String): Path {
+        val extensionWithDot = "." + extension.removePrefix(".")
+        val baseName = testDataPath.nameWithoutExtension
+
+        val testPrefix = this.testPrefix
+        if (testPrefix != null) {
+            val prefixedFile = testDataPath.resolveSibling("$baseName.$testPrefix$extensionWithDot")
+            if (prefixedFile.exists()) {
+                return prefixedFile
+            }
+        }
+
+        return testDataPath.resolveSibling(baseName + extensionWithDot)
+    }
 
     @OptIn(TestInfrastructureInternals::class)
     private val configure: TestConfigurationBuilder.() -> Unit = {
@@ -68,22 +104,12 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
         useSourcePreprocessor(::ExpressionMarkersSourceFilePreprocessor)
         useAdditionalService { ExpressionMarkerProvider() }
         useAdditionalService(::TestKtModuleProvider)
-        usePreAnalysisHandlers(::ModuleRegistrarPreAnalysisHandler.bind(disposable))
         configureTest(this)
 
         startingArtifactFactory = { ResultingArtifact.Source() }
-        this.testInfo = this@AbstractLowLevelApiTest.testInfo
+        this.testInfo = this@AbstractFrontendApiTest.testInfo
     }
 
-    protected lateinit var testDataPath: Path
-
-    protected fun testDataFileSibling(extension: String): Path {
-        val extensionWithDot = "." + extension.removePrefix(".")
-        return testDataPath.resolveSibling(testDataPath.nameWithoutExtension + extensionWithDot)
-    }
-
-    open fun configureTest(builder: TestConfigurationBuilder) {}
-
     protected fun runTest(@TestDataFile path: String) {
         testDataPath = Paths.get(path)
         val testConfiguration = testConfiguration(path, configure)
@@ -99,7 +125,6 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
             }
         }
 
-
         val singleModule = moduleStructure.modules.single()
         val project = testServices.compilerConfigurationProvider.getProject(singleModule)
         val moduleInfoProvider = testServices.projectModuleProvider
@@ -107,7 +132,7 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
         val moduleInfo = moduleInfoProvider.getModule(singleModule.name)
 
         with(project as MockProject) {
-            registerServicesForProject(this)
+            configurator.registerProjectServices(this)
         }
 
         registerApplicationServices()
@@ -122,11 +147,7 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
         }
         try {
             useDependedAnalysisSession = true
-            doTestByFileStructure(ktFiles.map {
+            doTestByFileStructure(configurator.processTestFiles(ktFiles), moduleStructure, testServices)
-                val fakeFile = it.copy() as KtFile
-                fakeFile.originalKtFile = it
-                fakeFile
-            }, moduleStructure, testServices)
         } catch (e: SkipDependedModeException) {
             // Skip the test if needed
         } catch (e: ExecutionException) {
@@ -140,16 +161,10 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
     private fun registerApplicationServices() {
         val application = ApplicationManager.getApplication() as MockApplication
         KotlinCoreEnvironment.underApplicationLock {
-            registerApplicationServices(application)
+            configurator.registerApplicationServices(application)
         }
     }
 
-    protected open fun registerServicesForProject(project: MockProject) {}
-
-    protected open fun registerApplicationServices(application: MockApplication) {}
-
-    protected abstract fun doTestByFileStructure(ktFiles: List<KtFile>, moduleStructure: TestModuleStructure, testServices: TestServices)
-
     @BeforeEach
     fun initTestInfo(testInfo: TestInfo) {
         this.testInfo = KotlinTestInfo(
@@ -159,35 +174,9 @@ abstract class AbstractLowLevelApiTest : TestWithDisposable() {
         )
     }
 
-    protected inline fun <R> analyseOnPooledThreadInReadAction(context: KtElement, crossinline action: KtAnalysisSession.() -> R): R =
+    protected class SkipDependedModeException : Exception()
-        executeOnPooledThreadInReadAction {
-            analyseForTest(context) { action() }
-        }
-
-    protected inline fun <T> runReadAction(crossinline runnable: () -> T): T {
-        return ApplicationManager.getApplication().runReadAction(Computable { runnable() })
-    }
-
-    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(contextElement.containingKtFile.originalKtFile!!, contextElement, action)
-        } else {
-            analyse(contextElement, action)
-        }
-    }
-
-    private class SkipDependedModeException : Exception()
 
     companion object {
         val DISABLE_DEPENDED_MODE_DIRECTIVE = "DISABLE_DEPENDED_MODE"
     }
-}
+}
-

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/ExpressionMarkersSourceFilePreprocessor.kt

@@ -3,13 +3,13 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.barebone.test
 
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.PrivateForInline
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentOfType
+import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
@@ -83,7 +83,6 @@ class ExpressionMarkerProvider : TestService {
             ?: error("No expression found at caret")
     }
 
-
     fun getSelectedElement(file: KtFile): KtElement {
         val range = selected[file.name]
             ?: error("No selected expression found in file")
@@ -99,7 +98,7 @@ class ExpressionMarkerProvider : TestService {
             .dropLastWhile { it is PsiWhiteSpace }
 }
 
-private fun String.indexOfOrNull(substring: String) =
-    indexOf(substring).takeIf { it >= 0 }
-
 val TestServices.expressionMarkerProvider: ExpressionMarkerProvider by TestServices.testServiceAccessor()
+
+fun String.indexOfOrNull(substring: String) =
+    indexOf(substring).takeIf { it >= 0 }

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestKtModuleProvider.kt

@@ -3,7 +3,7 @@
  * 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.compiler.based
+package org.jetbrains.kotlin.analysis.api.impl.barebone.test
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.psi.KtFile
@@ -21,12 +21,12 @@ class TestKtModuleProvider(
         cache[testModule.name] = TestKtSourceModule(project, testModule, ktFiles, testServices)
     }
 
-    internal fun getModuleInfoByKtFile(ktFile: KtFile): TestKtSourceModule =
+    fun getModuleInfoByKtFile(ktFile: KtFile): TestKtSourceModule =
         cache.values.first { moduleSourceInfo ->
             (if (ktFile.isPhysical) ktFile else ktFile.originalFile) in moduleSourceInfo.ktFiles
         }
 
-    internal fun getModule(moduleName: String): TestKtSourceModule =
+    fun getModule(moduleName: String): TestKtSourceModule =
         cache.getValue(moduleName)
 }
 

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestKtSourceModule.kt

@@ -3,7 +3,7 @@
  * 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.compiler.based
+package org.jetbrains.kotlin.analysis.api.impl.barebone.test
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.jvmModularRoots
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
@@ -32,7 +31,7 @@ import java.nio.file.Path
 import java.nio.file.Paths
 
 @OptIn(ExperimentalStdlibApi::class)
-internal class TestKtSourceModule(
+class TestKtSourceModule(
     override val project: Project,
     val testModule: TestModule,
     val testFilesToKtFiles: Map<TestFile, KtFile>,
@@ -57,10 +56,12 @@ internal class TestKtSourceModule(
             )
         }
     }
+
     override val directRefinementDependencies: List<KtModule> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         testModule.dependsOnDependencies
             .map { moduleProvider.getModule(it.moduleName) }
     }
+
     override val directFriendDependencies: List<KtModule> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         buildList {
             testModule.friendDependencies.mapTo(this) { moduleProvider.getModule(it.moduleName) }

analysis/analysis-api-impl-barebone/tests/org/jetbrains/kotlin/analysis/api/impl/barebone/test/TestWithDisposable.kt

@@ -3,7 +3,7 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.barebone.test
 
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.util.Disposer

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

@@ -0,0 +1,29 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    api(project(":compiler:psi"))
+    api(project(":analysis:analysis-api"))
+    api(project(":analysis:analysis-api-impl-barebone"))
+    api(intellijCoreDep()) { includeJars("intellij-core", rootProject = rootProject) }
+
+    testApiJUnit5()
+    testApi(project(":kotlin-test:kotlin-test-junit"))
+    testApi(project(":analysis:analysis-api"))
+    testApi(projectTests(":compiler:tests-common"))
+    testApi(projectTests(":compiler:test-infrastructure-utils"))
+    testApi(projectTests(":compiler:test-infrastructure"))
+    testApi(projectTests(":compiler:tests-common-new"))
+    testApi(projectTests(":analysis:analysis-api-impl-barebone"))
+    testImplementation(project(":kotlin-reflect"))
+    testImplementation(toolsJar())
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" { projectDefault() }
+}
+
+testsJar()

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/CachingKtAnalysisSessionProvider.kt

@@ -0,0 +1,85 @@
+/*
+ * 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.impl.base
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectRootModificationTracker
+import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.CachedValuesManager
+import com.intellij.psi.util.PsiModificationTracker
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
+import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.isValid
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityTokenFactory
+import org.jetbrains.kotlin.psi.KtElement
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.reflect.KClass
+
+@OptIn(InvalidWayOfUsingAnalysisSession::class)
+abstract class CachingKtAnalysisSessionProvider<State : Any>(private val project: Project) : KtAnalysisSessionProvider() {
+    private val cache = KtAnalysisSessionCache<Pair<State, KClass<out ValidityToken>>>(project)
+
+    protected abstract fun getResolveState(contextElement: KtElement): State
+    protected abstract fun getResolveState(contextSymbol: KtSymbol): State
+
+    protected abstract fun createAnalysisSession(
+        resolveState: State,
+        validityToken: ValidityToken,
+        contextElement: KtElement
+    ): KtAnalysisSession
+
+    @InvalidWayOfUsingAnalysisSession
+    final override fun getAnalysisSession(contextElement: KtElement, factory: ValidityTokenFactory): KtAnalysisSession {
+        val resolveState = getResolveState(contextElement)
+        return cache.getAnalysisSession(resolveState to factory.identifier) {
+            val validityToken = factory.create(project)
+            createAnalysisSession(resolveState, validityToken, contextElement)
+        }
+    }
+
+    final override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession {
+        val resolveState = getResolveState(contextSymbol)
+        val token = contextSymbol.token
+        return getCachedAnalysisSession(resolveState, token)
+            ?: error("analysis session was not found for ${contextSymbol::class}, symbol.isValid=${contextSymbol.isValid()}")
+    }
+
+    private fun getCachedAnalysisSession(resolveState: State, token: ValidityToken): KtAnalysisSession? {
+        return cache.getCachedAnalysisSession(resolveState to token::class)
+    }
+
+    @TestOnly
+    final override fun clearCaches() {
+        cache.clear()
+    }
+}
+
+private class KtAnalysisSessionCache<KEY : Any>(project: Project) {
+    private val cache = CachedValuesManager.getManager(project).createCachedValue {
+        CachedValueProvider.Result(
+            ConcurrentHashMap<KEY, KtAnalysisSession>(),
+            PsiModificationTracker.MODIFICATION_COUNT,
+            ProjectRootModificationTracker.getInstance(project),
+            project.createProjectWideOutOfBlockModificationTracker()
+        )
+    }
+
+    @TestOnly
+    fun clear() {
+        cache.value.clear()
+    }
+
+    inline fun getAnalysisSession(key: KEY, create: () -> KtAnalysisSession): KtAnalysisSession =
+        cache.value.getOrPut(key) { create() }
+
+    fun getCachedAnalysisSession(key: KEY): KtAnalysisSession? =
+        cache.value[key]
+}

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/KtMapBackedSubstitutor.kt

@@ -0,0 +1,14 @@
+/*
+ * 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.impl.base
+
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
+import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
+import org.jetbrains.kotlin.analysis.api.types.KtType
+
+interface KtMapBackedSubstitutor : KtSubstitutor {
+    fun getAsMap(): Map<KtTypeParameterSymbol, KtType>
+}

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/references/HLApiReferenceProviderService.kt

@@ -3,7 +3,7 @@
  * 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.idea.references
+package org.jetbrains.kotlin.analysis.api.impl.base.references
 
 import com.intellij.psi.ContributedReferenceHost
 import com.intellij.psi.PsiElement
@@ -15,7 +15,9 @@ import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.ConcurrentFactoryMap
 import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.idea.references.*
+import org.jetbrains.kotlin.idea.references.KotlinPsiReferenceProvider
+import org.jetbrains.kotlin.idea.references.KotlinPsiReferenceRegistrar
+import org.jetbrains.kotlin.idea.references.KotlinReferenceProviderContributor
 import org.jetbrains.kotlin.psi.KotlinReferenceProvidersService
 import org.jetbrains.kotlin.utils.SmartList
 

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/util/threadUtils.kt

@@ -1,16 +1,16 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.util
 
 import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.kotlin.analysis.api.tokens.HackToForceAllowRunningAnalyzeOnEDT
 import org.jetbrains.kotlin.analysis.api.tokens.hackyAllowRunningOnEdt
 
 @HackToForceAllowRunningAnalyzeOnEDT
-internal inline fun <R> runInPossiblyEdtThread(action: () -> R): R = when {
+inline fun <R> runInPossiblyEdtThread(action: () -> R): R = when {
     !ApplicationManager.getApplication().isDispatchThread -> action()
     else -> hackyAllowRunningOnEdt(action)
 }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/AbstractReferenceResolveTest.kt

@@ -3,7 +3,7 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test
 
 import com.intellij.psi.PsiReference
 import com.intellij.psi.impl.source.resolve.reference.impl.PsiMultiReference
@@ -11,11 +11,11 @@ import com.intellij.psi.util.PsiTreeUtil
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.components.RendererModifier
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleModuleTest
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleModuleTest
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithKind
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtDeclaration
@@ -120,7 +120,8 @@ abstract class AbstractReferenceResolveTest : AbstractHLApiSingleModuleTest() {
     }
 
     private val renderingOptions = KtDeclarationRendererOptions.DEFAULT.copy(
-        modifiers = RendererModifier.DEFAULT - RendererModifier.ANNOTATIONS
+        modifiers = RendererModifier.DEFAULT - RendererModifier.ANNOTATIONS,
+        sortNestedDeclarations = true
     )
 
     private fun PsiReference.unwrapMultiReferences(): List<PsiReference> = when (this) {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/SymbolByFqName.kt

@@ -3,7 +3,7 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test
 
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/commonTestUtils.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.impl.base.test
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.util.Computable
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.psi.KtElement
+
+inline fun <T> runReadAction(crossinline runnable: () -> T): T {
+    return ApplicationManager.getApplication().runReadAction(Computable { runnable() })
+}
+
+fun <R> executeOnPooledThreadInReadAction(action: () -> R): R =
+    ApplicationManager.getApplication().executeOnPooledThread<R> { runReadAction(action) }.get()
+
+inline fun <R> analyseOnPooledThreadInReadAction(context: KtElement, crossinline action: KtAnalysisSession.() -> R): R =
+    executeOnPooledThreadInReadAction {
+        analyse(context) { action() }
+    }

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/AbstractCompileTimeConstantEvaluatorTest.kt

@@ -3,11 +3,11 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.components
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.analysis.api.symbols.markers.*
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtValueArgument

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/AbstractExpectedExpressionTypeTest.kt

@@ -3,10 +3,12 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.components
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.analyse
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.base.test.executeOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/AbstractHLExpressionTypeTest.kt

@@ -3,10 +3,12 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.components
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.analyse
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.base.test.executeOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/AbstractHasCommonSubtypeTest.kt

@@ -3,11 +3,12 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.components
 
 import com.intellij.openapi.util.text.StringUtil
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtTreeVisitorVoid

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/AbstractOverriddenDeclarationProviderTest.kt

@@ -3,13 +3,14 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.components
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleModuleTest
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentsOfType
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
+import org.jetbrains.kotlin.analysis.api.impl.base.test.executeOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleModuleTest
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSyntheticJavaPropertySymbol

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/components/AbstractRendererTest.kt

@@ -3,11 +3,13 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.components
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.analyse
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
+import org.jetbrains.kotlin.analysis.api.impl.base.test.executeOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
@@ -18,7 +20,8 @@ abstract class AbstractRendererTest : AbstractHLApiSingleFileTest() {
         val options = KtDeclarationRendererOptions.DEFAULT.copy(
             approximateTypes = true,
             renderContainingDeclarations = true,
-            typeRendererOptions = KtTypeRendererOptions.SHORT_NAMES
+            typeRendererOptions = KtTypeRendererOptions.SHORT_NAMES,
+            sortNestedDeclarations = true
         )
 
         val actual = executeOnPooledThreadInReadAction {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/fir/AbstractResolveCallTest.kt

@@ -3,7 +3,7 @@
  * 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
+package org.jetbrains.kotlin.analysis.api.impl.base.test.fir
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
@@ -11,14 +11,14 @@ import org.jetbrains.kotlin.analysis.api.calls.KtCall
 import org.jetbrains.kotlin.analysis.api.calls.KtDelegatedConstructorCallKind
 import org.jetbrains.kotlin.analysis.api.calls.KtErrorCallTarget
 import org.jetbrains.kotlin.analysis.api.calls.KtSuccessCallTarget
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleModuleTest
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
-import org.jetbrains.kotlin.analysis.api.fir.types.KtFirSubstitutor
+import org.jetbrains.kotlin.analysis.api.impl.base.KtMapBackedSubstitutor
+import org.jetbrains.kotlin.analysis.api.impl.base.test.executeOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleModuleTest
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtPossibleMemberSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
-import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
@@ -91,6 +91,7 @@ private fun KtCall.stringRepresentation(): String {
             append(": ${annotatedType.type.render()}")
         }
         is KtValueParameterSymbol -> "${if (isVararg) "vararg " else ""}$name: ${annotatedType.type.render()}"
+        is KtTypeParameterSymbol -> this.nameOrAnonymous.asString()
         is KtVariableSymbol -> "${if (isVal) "val" else "var"} $name: ${annotatedType.type.render()}"
         is KtSuccessCallTarget -> symbol.stringValue()
         is KtErrorCallTarget -> "ERR<${this.diagnostic.defaultMessage}, [${candidates.joinToString { it.stringValue() }}]>"
@@ -99,12 +100,12 @@ private fun KtCall.stringRepresentation(): String {
         is KtExpression -> this.text
         is KtDelegatedConstructorCallKind -> toString()
         is KtSubstitutor.Empty -> "<empty substitutor>"
-        is KtFirSubstitutor -> {
+        is KtMapBackedSubstitutor -> {
-            when (val substitutor = substitutor) {
+            val mappingText = getAsMap().orEmpty().entries
-                is ConeSubstitutorByMap -> "<map substitutor: ${substitutor.substitution}>"
+                .joinToString(prefix = "{", postfix = "}") { (k, v) -> k.stringValue() + " = " + v.asStringForDebugging() }
-                else -> "<complex substitutor>"
+            "<map substitutor: $mappingText>"
-            }
         }
+        is KtSubstitutor -> "<complex substitutor>"
         else -> error("unexpected parameter type ${this::class}")
     }
 

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/scopes/AbstractFileScopeTest.kt

@@ -3,9 +3,11 @@
  * 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.scopes
+package org.jetbrains.kotlin.analysis.api.impl.base.test.scopes
 
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
+import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.impl.base.test.executeOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.analysis.api.symbols.DebugSymbolRenderer
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/scopes/AbstractMemberScopeTest.kt

@@ -3,11 +3,11 @@
  * 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.scopes
+package org.jetbrains.kotlin.analysis.api.impl.base.test.scopes
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.SymbolByFqName
+import org.jetbrains.kotlin.analysis.api.impl.base.test.SymbolByFqName
-import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractSymbolByFqNameTest
+import org.jetbrains.kotlin.analysis.api.impl.base.test.symbols.AbstractSymbolByFqNameTest
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.psi.KtFile

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/symbols/AbstractSymbolByFqNameTest.kt

@@ -3,10 +3,10 @@
  * 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.symbols
+package org.jetbrains.kotlin.analysis.api.impl.base.test.symbols
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.fir.SymbolByFqName
+import org.jetbrains.kotlin.analysis.api.impl.base.test.SymbolByFqName
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/symbols/AbstractSymbolByPsiTest.kt

@@ -3,7 +3,7 @@
  * 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.symbols
+package org.jetbrains.kotlin.analysis.api.impl.base.test.symbols
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/symbols/AbstractSymbolByReferenceTest.kt

@@ -3,10 +3,10 @@
  * 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.symbols
+package org.jetbrains.kotlin.analysis.api.impl.base.test.symbols
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.KtFile

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/symbols/AbstractSymbolTest.kt

@@ -1,14 +1,13 @@
 /*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.symbols
+package org.jetbrains.kotlin.analysis.api.impl.base.test.symbols
 
-import com.intellij.openapi.components.ServiceManager
-import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
-import org.jetbrains.kotlin.analysis.api.fir.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.impl.base.test.analyseOnPooledThreadInReadAction
+import org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework.AbstractHLApiSingleFileTest
 import org.jetbrains.kotlin.analysis.api.symbols.DebugSymbolRenderer
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
@@ -30,6 +29,8 @@ abstract class AbstractSymbolTest : AbstractHLApiSingleFileTest() {
 
     abstract fun KtAnalysisSession.collectSymbols(ktFile: KtFile, testServices: TestServices): List<KtSymbol>
 
+    abstract fun doOutOfBlockModification(ktFile: KtFile)
+
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
         val createPointers = SymbolTestDirectives.DO_NOT_CHECK_SYMBOL_RESTORE !in module.directives
         val pointersWithRendered = analyseOnPooledThreadInReadAction(ktFile) {
@@ -74,11 +75,6 @@ abstract class AbstractSymbolTest : AbstractHLApiSingleFileTest() {
         val actual = restored.joinToString(separator = "\n")
         testServices.assertions.assertEqualsToFile(testDataFileSibling(".txt"), actual)
     }
-
-    private fun doOutOfBlockModification(ktFile: KtFile) {
-        ServiceManager.getService(ktFile.project, KotlinModificationTrackerFactory::class.java)
-            .incrementModificationsCount()
-    }
 }
 
 private object SymbolTestDirectives : SimpleDirectivesContainer() {

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/test/framework/AbstractHLApiSingleFileTest.kt

@@ -3,7 +3,7 @@
  * 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.test.framework
+package org.jetbrains.kotlin.analysis.api.impl.base.test.test.framework
 
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestModule

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/test/framework/AbstractHLApiSingleModuleTest.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.impl.base.test.test.framework
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.util.Computable
+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.api.impl.barebone.test.AbstractFrontendApiTest
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.model.TestModule
+import org.jetbrains.kotlin.test.services.TestModuleStructure
+import org.jetbrains.kotlin.test.services.TestServices
+
+abstract class AbstractHLApiSingleModuleTest : AbstractFrontendApiTest() {
+    final override fun doTestByFileStructure(ktFiles: List<KtFile>, moduleStructure: TestModuleStructure, testServices: TestServices) {
+        val singleModule = moduleStructure.modules.single()
+        doTestByFileStructure(ktFiles, singleModule, testServices)
+    }
+
+    protected abstract fun doTestByFileStructure(ktFiles: List<KtFile>, module: TestModule, testServices: TestServices)
+
+    protected inline fun <R> analyseOnPooledThreadInReadAction(context: KtElement, crossinline action: KtAnalysisSession.() -> R): R =
+        executeOnPooledThreadInReadAction {
+            analyseForTest(context) { action() }
+        }
+
+    protected inline fun <T> runReadAction(crossinline runnable: () -> T): T {
+        return ApplicationManager.getApplication().runReadAction(Computable { runnable() })
+    }
+
+    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)
+        }
+    }
+}

analysis/low-level-api-fir/build.gradle.kts

@@ -16,6 +16,7 @@ dependencies {
     api(project(":compiler:fir:checkers:checkers.jvm"))
     api(project(":compiler:fir:java"))
     api(project(":compiler:backend.common.jvm"))
+    api(project(":analysis:analysis-api-impl-barebone"))
     testApi(project(":analysis:analysis-api-fir"))
     implementation(project(":compiler:ir.psi2ir"))
     implementation(project(":compiler:fir:entrypoint"))
@@ -32,6 +33,7 @@ dependencies {
     testApi(toolsJar())
     testApi(projectTests(":compiler:tests-common"))
     testApi(projectTests(":compiler:fir:analysis-tests:legacy-fir-tests"))
+    testApi(projectTests(":analysis:analysis-api-impl-barebone"))
     testApi(project(":kotlin-test:kotlin-test-junit"))
     testApiJUnit5()
     testApi(project(":kotlin-reflect"))

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirModuleResolveStateDepended.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.InternalForInline
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.InternalForInline
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirModuleResolveStateImpl.kt

@@ -6,7 +6,16 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.InternalForInline
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.InternalForInline
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
+import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.DiagnosticsCollector
@@ -28,15 +37,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
-import org.jetbrains.kotlin.fir.expressions.FirAnonymousObjectExpression
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.psi.*
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirModuleResolveState.kt

@@ -6,10 +6,10 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.InternalForInline
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.InternalForInline
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.analysis.project.structure.KtModule

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacade.kt

@@ -6,13 +6,12 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.InternalForInline
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirIdeResolveStateService
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.InternalForInline
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveType
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
-import org.jetbrains.kotlin.analyzer.ModuleSourceInfoBase
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
 import org.jetbrains.kotlin.fir.declarations.*

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt

@@ -6,7 +6,19 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.DeclarationCopyBuilder.withBodyFrom
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.realPsi
+import org.jetbrains.kotlin.fir.resolve.ScopeSession
+import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
+import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
+import org.jetbrains.kotlin.fir.scopes.createImportingScopes
+import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
+import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateDepended
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateImpl
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FileTowerProvider
@@ -20,19 +32,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.firIdeProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.FirIdeSourcesSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentOfType
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentsOfType
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
-import org.jetbrains.kotlin.fir.FirElement
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirAnnotation
-import org.jetbrains.kotlin.fir.realPsi
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector
-import org.jetbrains.kotlin.fir.scopes.createImportingScopes
-import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/FirElementBuilder.kt

@@ -7,11 +7,11 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.ThreadSafe
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.ThreadSafe
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirModuleResolveState
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/FirFileBuilder.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder
 
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.ThreadSafe
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirPhaseRunner
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.ThreadSafe
 import org.jetbrains.kotlin.psi.KtFile
 
 /**

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/LockProvider.kt

@@ -5,8 +5,8 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder
 
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.PrivateForInline
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.PrivateForInline
 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.ResolveTreeBuilder
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.lockWithPCECheck
 import java.util.concurrent.locks.ReentrantLock

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/builder/ModuleFileCache.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder
 
 import com.intellij.concurrency.ConcurrentCollectionFactory
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.ThreadSafe
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -13,7 +14,6 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.ThreadSafe
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtFile

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/NonLocalDeclarationUtils.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
 
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
 import org.jetbrains.kotlin.fir.FirFakeSourceElement
 import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.parentOfType
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/FirIdeSessionProvider.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analysis.low.level.api.fir.annotations.Immutable
+import org.jetbrains.kotlin.analysis.api.impl.barebone.annotations.Immutable
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/utils.kt

@@ -12,6 +12,8 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import com.intellij.psi.util.*
+import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
+import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.cfg.containingDeclarationForPseudocode
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -20,8 +22,6 @@ import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
-import org.jetbrains.kotlin.psi.psiUtil.parents
-import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.locks.Lock
 import kotlin.reflect.KProperty
@@ -135,15 +135,4 @@ fun KtElement.getElementTextInContext(): String {
     return builder.toString().trimIndent().trim()
 }
 
-private const val ELEMENT_TAG = "ELEMENT"
+private const val ELEMENT_TAG = "ELEMENT"
-
-inline fun <reified T : PsiElement> PsiElement.parentOfType(withSelf: Boolean = false): T? {
-    return PsiTreeUtil.getParentOfType(this, T::class.java, !withSelf)
-}
-
-fun <T : PsiElement> PsiElement.parentsOfType(clazz: Class<out T>, withSelf: Boolean = true): Sequence<T> {
-    return (if (withSelf) parentsWithSelf else parents).filterIsInstance(clazz)
-}
-
-inline fun <reified T : PsiElement> PsiElement.parentsOfType(withSelf: Boolean = true): Sequence<T> =
-    parentsOfType(T::class.java, withSelf)

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractGetOrBuildFirTest.kt

@@ -7,13 +7,13 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.expressionMarkerProvider
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
-import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.expressionMarkerProvider
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt

@@ -5,14 +5,14 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
 
-import com.intellij.openapi.Disposable
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.AbstractCompilerBasedTest
-import com.intellij.openapi.util.Disposer
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.TestKtModuleProvider
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.createResolveStateForNoCaching
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.FirLazyTransformerForIDE
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.test.TestConfiguration
 import org.jetbrains.kotlin.test.bind
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.builders.firHandlersStep
@@ -20,28 +20,14 @@ import org.jetbrains.kotlin.test.builders.testConfiguration
 import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives
 import org.jetbrains.kotlin.test.directives.model.DirectivesContainer
 import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact
-import org.jetbrains.kotlin.test.model.*
+import org.jetbrains.kotlin.test.model.DependencyKind
-import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
+import org.jetbrains.kotlin.test.model.FrontendFacade
-import org.jetbrains.kotlin.test.services.*
+import org.jetbrains.kotlin.test.model.FrontendKinds
-import org.junit.jupiter.api.AfterEach
+import org.jetbrains.kotlin.test.model.TestModule
-import org.junit.jupiter.api.BeforeEach
+import org.jetbrains.kotlin.test.services.TestServices
-import org.junit.jupiter.api.TestInfo
+import org.jetbrains.kotlin.test.services.compilerConfigurationProvider
-
-abstract class AbstractCompilerBasedTest : AbstractKotlinCompilerTest() {
-    private var _disposable: Disposable? = null
-    protected val disposable: Disposable get() = _disposable!!
-
-    @BeforeEach
-    private fun intiDisposable(testInfo: TestInfo) {
-        _disposable = Disposer.newDisposable("disposable for ${testInfo.displayName}")
-    }
-
-    @AfterEach
-    private fun disposeDisposable() {
-        _disposable?.let { Disposer.dispose(it) }
-        _disposable = null
-    }
 
+abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() {
     final override fun TestConfigurationBuilder.configuration() {
         globalDefaults {
             frontend = FrontendKinds.FIR
@@ -62,7 +48,6 @@ abstract class AbstractCompilerBasedTest : AbstractKotlinCompilerTest() {
 
     open fun TestConfigurationBuilder.configureTest() {}
 
-
     inner class LowLevelFirFrontendFacade(
         testServices: TestServices
     ) : FrontendFacade<FirOutputArtifact>(testServices, FrontendKinds.FIR) {
@@ -103,14 +88,4 @@ abstract class AbstractCompilerBasedTest : AbstractKotlinCompilerTest() {
             FirLazyTransformerForIDE.enableDeepEnsure = oldEnableDeepEnsure
         }
     }
-
+}
-    private fun ignoreTest(filePath: String, configuration: TestConfiguration): Boolean {
-        val modules = configuration.moduleStructureExtractor.splitTestDataByModules(filePath, configuration.directives)
-
-        if (modules.modules.none { it.files.any { it.isKtFile } }) {
-            return true // nothing to highlight
-        }
-
-        return false
-    }
-}

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/ModuleRegistrarPreAnalysisHandler.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
 
 import com.intellij.mock.MockProject
 import com.intellij.openapi.Disposable
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider
 import org.jetbrains.kotlin.test.services.*
 
 class ModuleRegistrarPreAnalysisHandler(

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/testServices.kt

@@ -13,6 +13,7 @@ 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.fir.KtFirAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.projectModuleProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.FirIdeResolveStateService
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosisCompilerTestDataSpecTest.kt

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTest
+import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTestForFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.addIdeTestIgnoreHandler
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.runners.baseFirDiagnosticTestConfiguration
 import org.jetbrains.kotlin.test.runners.baseFirSpecDiagnosticTestConfiguration
 
-abstract class AbstractDiagnosisCompilerTestDataSpecTest : AbstractCompilerBasedTest() {
+abstract class AbstractDiagnosisCompilerTestDataSpecTest : AbstractCompilerBasedTestForFir() {
     override fun TestConfigurationBuilder.configureTest() {
         baseFirDiagnosticTestConfiguration(frontendFacade = ::LowLevelFirFrontendFacade)
         baseFirSpecDiagnosticTestConfiguration()

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/AbstractDiagnosisCompilerTestDataTest.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTest
+import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.AbstractCompilerBasedTestForFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.addIdeTestIgnoreHandler
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.runners.baseFirDiagnosticTestConfiguration
 
-abstract class AbstractDiagnosisCompilerTestDataTest : AbstractCompilerBasedTest() {
+abstract class AbstractDiagnosisCompilerTestDataTest : AbstractCompilerBasedTestForFir() {
     override fun TestConfigurationBuilder.configureTest() {
         baseFirDiagnosticTestConfiguration(frontendFacade = ::LowLevelFirFrontendFacade)
         addIdeTestIgnoreHandler()

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

@@ -5,4 +5,10 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.test.base
 
-abstract class AbstractLowLevelApiSingleModuleTest : AbstractLowLevelApiTest()
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.AbstractFrontendApiTest
+import org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+
+abstract class AbstractLowLevelApiSingleModuleTest : AbstractFrontendApiTest() {
+    override val configurator: FrontendApiTestConfiguratorService
+        get() = FirLowLevelFrontendApiTestConfiguratorService
+}

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

@@ -0,0 +1,37 @@
+/*
+ * 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 org.jetbrains.kotlin.analysis.api.impl.barebone.test.FrontendApiTestConfiguratorService
+import org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based.ModuleRegistrarPreAnalysisHandler
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalKtFile
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.test.bind
+import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+
+object FirLowLevelFrontendApiTestConfiguratorService : FrontendApiTestConfiguratorService {
+    override fun TestConfigurationBuilder.configureTest(disposable: Disposable) {
+        usePreAnalysisHandlers(::ModuleRegistrarPreAnalysisHandler.bind(disposable))
+    }
+
+    override fun processTestFiles(files: List<KtFile>): List<KtFile> {
+        return files.map {
+            val fakeFile = it.copy() as KtFile
+            fakeFile.originalKtFile = it
+            fakeFile
+        }
+    }
+
+    override fun getOriginalFile(file: KtFile): KtFile {
+        return file.originalKtFile!!
+    }
+
+    override fun registerProjectServices(project: MockProject) {}
+    override fun registerApplicationServices(application: MockApplication) {}
+}

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

@@ -5,13 +5,8 @@
 
 package org.jetbrains.kotlin.generators.tests.analysis.api
 
-import org.jetbrains.kotlin.analysis.api.fir.AbstractReferenceResolveTest
+import org.jetbrains.kotlin.analysis.api.fir.AbstractFirReferenceResolveTest
 import org.jetbrains.kotlin.analysis.api.fir.components.*
-import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFileScopeTest
-import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractMemberScopeByFqNameTest
-import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractSymbolByFqNameTest
-import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractSymbolByPsiTest
-import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractSymbolByReferenceTest
 import org.jetbrains.kotlin.analysis.low.level.api.fir.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.AbstractDiagnosticTraversalCounterTest
 import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.AbstractFirContextCollectionTest
@@ -20,6 +15,15 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostic.compiler.based
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.AbstractFileStructureTest
 import org.jetbrains.kotlin.analysis.low.level.api.fir.resolve.AbstractInnerDeclarationsResolvePhaseTest
 import org.jetbrains.kotlin.generators.util.TestGeneratorUtil
+import org.jetbrains.kotlin.analysis.api.fir.components.AbstractFirExpectedExpressionTypeTest
+import org.jetbrains.kotlin.analysis.api.fir.components.AbstractFirHLExpressionTypeTest
+import org.jetbrains.kotlin.analysis.api.fir.components.AbstractFirOverriddenDeclarationProviderTest
+import org.jetbrains.kotlin.analysis.api.fir.components.AbstractFirRendererTest
+import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirFileScopeTest
+import org.jetbrains.kotlin.analysis.api.fir.scopes.AbstractFirMemberScopeByFqNameTest
+import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByFqNameTest
+import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByPsiTest
+import org.jetbrains.kotlin.analysis.api.fir.symbols.AbstractFirSymbolByReferenceTest
 import org.jetbrains.kotlin.spec.utils.GeneralConfiguration
 import org.jetbrains.kotlin.spec.utils.tasks.detectDirsWithTestsMapFileOnly
 import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5
@@ -33,51 +37,51 @@ fun main(args: Array<String>) {
 
     generateTestGroupSuiteWithJUnit5(args) {
         testGroup("analysis/analysis-api-fir/tests", "analysis/analysis-api/testData") {
-            testClass<AbstractResolveCallTest> {
+            testClass<AbstractFirResolveCallTest> {
                 model("analysisSession/resolveCall")
             }
 
-            testClass<AbstractMemberScopeByFqNameTest> {
+            testClass<AbstractFirMemberScopeByFqNameTest> {
                 model("memberScopeByFqName")
             }
 
-            testClass<AbstractFileScopeTest> {
+            testClass<AbstractFirFileScopeTest> {
                 model("fileScopeTest", extension = "kt")
             }
 
-            testClass<AbstractSymbolByPsiTest> {
+            testClass<AbstractFirSymbolByPsiTest> {
                 model("symbols/symbolByPsi")
             }
 
-            testClass<AbstractSymbolByFqNameTest> {
+            testClass<AbstractFirSymbolByFqNameTest> {
                 model("symbols/symbolByFqName")
             }
 
-            testClass<AbstractSymbolByReferenceTest> {
+            testClass<AbstractFirSymbolByReferenceTest> {
                 model("symbols/symbolByReference")
             }
 
-            testClass<AbstractCompileTimeConstantEvaluatorTest> {
+            testClass<AbstractFirCompileTimeConstantEvaluatorTest> {
                 model("components/compileTimeConstantEvaluator")
             }
 
-            testClass<AbstractExpectedExpressionTypeTest> {
+            testClass<AbstractFirExpectedExpressionTypeTest> {
                 model("components/expectedExpressionType")
             }
 
-            testClass<AbstractOverriddenDeclarationProviderTest> {
+            testClass<AbstractFirOverriddenDeclarationProviderTest> {
                 model("components/overridenDeclarations")
             }
 
-            testClass<AbstractHLExpressionTypeTest> {
+            testClass<AbstractFirHLExpressionTypeTest> {
                 model("components/expressionType")
             }
 
-            testClass<AbstractRendererTest> {
+            testClass<AbstractFirRendererTest> {
                 model("components/declarationRenderer")
             }
 
-            testClass<AbstractReferenceResolveTest> {
+            testClass<AbstractFirReferenceResolveTest> {
                 model("referenceResolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME)
             }
 
@@ -85,11 +89,11 @@ fun main(args: Array<String>) {
                 model("components/importOptimizer", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME)
             }
 
-            testClass<AbstractHasCommonSubtypeTest> {
+            testClass<AbstractFirHasCommonSubtypeTest> {
                 model("components/hasCommonSubtype")
             }
 
-            testClass<AbstractGetSuperTypesTest> {
+            testClass<AbstractFirGetSuperTypesTest> {
                 model("components/getSuperTypes")
             }
         }

settings.gradle

@@ -474,6 +474,8 @@ include ":generators:analysis-api-generator",
         ":analysis:analysis-api-fir:analysis-api-fir-generator",
         ":analysis:analysis-api-fir",
         ":analysis:analysis-api",
+        ":analysis:analysis-api-impl-barebone",
+        ":analysis:analysis-api-impl-base",
         ":analysis:analysis-api-providers",
         ":analysis:symbol-light-classes",
         ":analysis:project-structure"