[analysis api] rename analyse -> analyze to match American word spelling

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt

@@ -5,9 +5,9 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors
 
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -19,8 +19,8 @@ import java.lang.UnsupportedOperationException
 @InvalidWayOfUsingAnalysisSession
 class KtFe10AnalysisSessionProvider : KtAnalysisSessionProvider() {
     @InvalidWayOfUsingAnalysisSession
-    override fun getAnalysisSession(contextElement: KtElement, factory: KtLifetimeTokenFactory): KtAnalysisSession {
+    override fun getAnalysisSession(useSiteKtElement: KtElement, factory: KtLifetimeTokenFactory): KtAnalysisSession {
-        return KtFe10AnalysisSession(contextElement, factory.create(contextElement.project))
+        return KtFe10AnalysisSession(useSiteKtElement, factory.create(useSiteKtElement.project))
     }
 
     @InvalidWayOfUsingAnalysisSession
@@ -37,7 +37,7 @@ class KtFe10AnalysisSessionProvider : KtAnalysisSessionProvider() {
         throw UnsupportedOperationException("getAnalysisSessionBySymbol() should not be used on KtFe10AnalysisSession")
     }
 
-    override fun getAnalysisSessionByUseSiteKtModule(ktModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession {
+    override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession {
         throw UnsupportedOperationException("getAnalysisSessionByModule() should not be used on KtFe10AnalysisSession")
     }
 

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.references.base
 import com.intellij.psi.PsiElementResolveResult
 import com.intellij.psi.ResolveResult
 import com.intellij.psi.impl.source.resolve.ResolveCache
-import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.session.analyze
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.impl.base.util.runInPossiblyEdtThread
@@ -32,7 +32,7 @@ object KtFe10PolyVariantResolver : ResolveCache.PolyVariantResolver<KtReference>
         require(reference is AbstractKtReference<*>) { "reference should be AbstractKtReference, but was ${reference::class}" }
         return runInPossiblyEdtThread {
             val expression = reference.expression
-            analyse(reference.expression) {
+            analyze(reference.expression) {
                 val analysisSession = this as KtFe10AnalysisSession
                 val bindingContext = analysisSession.analysisContext.analyze(expression, AnalysisMode.PARTIAL)
                 val descriptor = when (expression) {

analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/test/configurator/AnalysisApiFe10TestServiceRegistrar.kt

@@ -9,8 +9,8 @@ import com.intellij.core.CoreJavaFileManager
 import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
 import com.intellij.psi.impl.file.impl.JavaFileManager
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.CliFe10AnalysisFacade
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisHandlerExtension

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.fir
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.components.*
 import org.jetbrains.kotlin.analysis.api.fir.components.*

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.fir
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider

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

@@ -13,7 +13,7 @@ import com.intellij.psi.ResolveResult
 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.session.analyze
 import org.jetbrains.kotlin.analysis.api.impl.base.util.runInPossiblyEdtThread
 
 object KtFirReferenceResolver : ResolveCache.PolyVariantResolver<KtReference> {
@@ -25,7 +25,7 @@ object KtFirReferenceResolver : ResolveCache.PolyVariantResolver<KtReference> {
         check(ref is AbstractKtReference<*>) { "reference should be AbstractKtReference, but was ${ref::class}" }
         return runInPossiblyEdtThread {
             val resolveToPsiElements = try {
-                analyse(ref.expression) { ref.getResolvedToPsi(this) }
+                analyze(ref.expression) { ref.getResolvedToPsi(this) }
             } catch (e: Throwable) {
                 if (e is ControlFlowException || e is IndexNotReadyException) throw e
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.utils
 
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.buildSymbol

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

@@ -12,9 +12,9 @@ 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.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.api.tokens.KtLifetimeToken
@@ -46,8 +46,8 @@ abstract class CachingKtAnalysisSessionProvider<State : Any>(project: Project) :
         }
     }
 
-    final override fun getAnalysisSessionByUseSiteKtModule(ktModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession {
+    final override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession {
-        val firResolveSession = getFirResolveSession(ktModule)
+        val firResolveSession = getFirResolveSession(useSiteKtModule)
         return cache.getAnalysisSession(firResolveSession to factory.identifier) {
             val validityToken = factory.create(project)
             createAnalysisSession(firResolveSession, validityToken)

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiExpressionPsiTypeProviderTest.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.psiTypeProvider
 
-import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.session.analyze
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
 import org.jetbrains.kotlin.psi.KtExpression
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.test.services.assertions
 abstract class AbstractAnalysisApiExpressionPsiTypeProviderTest : AbstractAnalysisApiSingleFileTest(){
     override fun doTestByFileStructure(ktFile: KtFile, module: TestModule, testServices: TestServices) {
         val declarationAtCaret = testServices.expressionMarkerProvider.getSelectedElement(ktFile) as KtExpression
-        val actual = analyse(ktFile) {
+        val actual = analyze(ktFile) {
             val returnType = declarationAtCaret.getKtType()
                 ?: error("Not a typable expression ${declarationAtCaret::class} ${declarationAtCaret.text}")
             val psiType = returnType.asPsiType(declarationAtCaret)

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiPsiTypeProviderTest.kt

@@ -9,7 +9,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiElementVisitor
-import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.session.analyze
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
 import org.jetbrains.kotlin.analysis.test.framework.utils.executeOnPooledThreadInReadAction
@@ -36,7 +36,7 @@ abstract class AbstractAnalysisApiPsiTypeProviderTest : AbstractAnalysisApiSingl
             ?: error("Can't find psi context for $declaration")
         val actual = buildString {
             executeOnPooledThreadInReadAction {
-                analyse(declaration) {
+                analyze(declaration) {
                     val ktType = declaration.getReturnKtType()
                     appendLine("KtType: ${ktType.render()}")
                     appendLine("PsiType: ${ktType.asPsiType(psiContext)}")

analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.typeProvider
 
-import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.session.analyze
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.base.AbstractAnalysisApiSingleFileTest
@@ -21,7 +21,7 @@ abstract class AbstractAnalysisApiGetSuperTypesTest : AbstractAnalysisApiSingleF
         val expression = testServices.expressionMarkerProvider.getSelectedElement(ktFile)
 
         val actual = executeOnPooledThreadInReadAction {
-            analyse(expression) {
+            analyze(expression) {
                 val expectedType = expression.getExpectedType() ?: error("expect to get type of expression '${expression.text}'")
                 val directSuperTypes = expectedType.getDirectSuperTypes()
                 val approximatedDirectSuperTypes = expectedType.getDirectSuperTypes(shouldApproximate = true)

analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeUtils.kt

@@ -12,8 +12,8 @@ import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.impl.base.references.HLApiReferenceProviderService
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSessionProvider.kt

@@ -1,208 +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
-
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.components.ServiceManager
-import com.intellij.openapi.progress.ProgressIndicator
-import com.intellij.openapi.progress.Task
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.util.Computable
-import org.jetbrains.annotations.TestOnly
-import org.jetbrains.kotlin.analysis.api.session.KtDefaultLifetimeTokenProvider
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
-import org.jetbrains.kotlin.analysis.api.tokens.KtLifetimeTokenFactory
-import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.psi.KtFile
-
-@RequiresOptIn("To use analysis session, consider using analyze/analyzeWithReadAction/analyseInModalWindow methods")
-public annotation class InvalidWayOfUsingAnalysisSession
-
-@RequiresOptIn
-public annotation class KtAnalysisSessionProviderInternals
-
-/**
- * Provides [KtAnalysisSession] by [contextElement]
- * Should not be used directly, consider using [analyse]/[analyseWithReadAction]/[analyseInModalWindow] instead
- */
-@InvalidWayOfUsingAnalysisSession
-public abstract class KtAnalysisSessionProvider(public val project: Project) : Disposable {
-
-    @Suppress("LeakingThis")
-    @OptIn(KtInternalApiMarker::class)
-    public val noWriteActionInAnalyseCallChecker: NoWriteActionInAnalyseCallChecker = NoWriteActionInAnalyseCallChecker(this)
-
-    @InvalidWayOfUsingAnalysisSession
-    public abstract fun getAnalysisSession(contextElement: KtElement, factory: KtLifetimeTokenFactory): KtAnalysisSession
-
-    @InvalidWayOfUsingAnalysisSession
-    public abstract fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession
-
-    @InvalidWayOfUsingAnalysisSession
-    public abstract fun getAnalysisSessionByUseSiteKtModule(ktModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession
-
-    @InvalidWayOfUsingAnalysisSession
-    public inline fun <R> analyzeWithSymbolAsContext(
-        contextSymbol: KtSymbol,
-        action: KtAnalysisSession.() -> R
-    ): R {
-        val analysisSession = getAnalysisSessionBySymbol(contextSymbol)
-        return action(analysisSession)
-    }
-
-    @InvalidWayOfUsingAnalysisSession
-    public inline fun <R> analyseInDependedAnalysisSession(
-        originalFile: KtFile,
-        elementToReanalyze: KtElement,
-        nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory?,
-        action: KtAnalysisSession.() -> R
-    ): R {
-        val factory =
-            nonDefaultLifetimeTokenFactory ?: KtDefaultLifetimeTokenProvider.getService(project).getDefaultLifetimeTokenFactory()
-
-        val originalAnalysisSession = getAnalysisSession(originalFile, factory)
-        val dependedAnalysisSession = originalAnalysisSession
-            .createContextDependentCopy(originalFile, elementToReanalyze)
-        return analyse(dependedAnalysisSession, factory, action)
-    }
-
-    @InvalidWayOfUsingAnalysisSession
-    public inline fun <R> analyse(
-        contextElement: KtElement,
-        nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory?,
-        action: KtAnalysisSession.() -> R
-    ): R {
-        val factory =
-            nonDefaultLifetimeTokenFactory ?: KtDefaultLifetimeTokenProvider.getService(project).getDefaultLifetimeTokenFactory()
-        return analyse(getAnalysisSession(contextElement, factory), factory, action)
-    }
-
-    @InvalidWayOfUsingAnalysisSession
-    public inline fun <R> analyze(
-        useSiteKtModule: KtModule,
-        nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory?,
-        action: KtAnalysisSession.() -> R
-    ): R {
-        val factory =
-            nonDefaultLifetimeTokenFactory ?: KtDefaultLifetimeTokenProvider.getService(project).getDefaultLifetimeTokenFactory()
-
-        return analyse(getAnalysisSessionByUseSiteKtModule(useSiteKtModule, factory), factory, action)
-    }
-
-    @OptIn(KtAnalysisSessionProviderInternals::class, KtInternalApiMarker::class)
-    @InvalidWayOfUsingAnalysisSession
-    public inline fun <R> analyse(
-        analysisSession: KtAnalysisSession,
-        factory: KtLifetimeTokenFactory,
-        action: KtAnalysisSession.() -> R
-    ): R {
-        noWriteActionInAnalyseCallChecker.beforeEnteringAnalysisContext()
-        factory.beforeEnteringAnalysisContext()
-        return try {
-            analysisSession.action()
-        } finally {
-            factory.afterLeavingAnalysisContext()
-            noWriteActionInAnalyseCallChecker.afterLeavingAnalysisContext()
-        }
-    }
-
-    @TestOnly
-    public abstract fun clearCaches()
-
-    override fun dispose() {}
-
-    public companion object {
-        public fun getInstance(project: Project): KtAnalysisSessionProvider =
-            ServiceManager.getService(project, KtAnalysisSessionProvider::class.java)
-    }
-}
-
-/**
- * Execute given [action] in [KtAnalysisSession] context
- * Uses [contextElement] to get a module from which you would like to see the other modules
- * Usually [contextElement] is some element form the module you currently analysing now
- *
- * Should not be called from EDT thread
- * Should be called from read action
- * To analyse something from EDT thread, consider using [analyseInModalWindow]
- *
- * @see KtAnalysisSession
- * @see analyseWithReadAction
- */
-@OptIn(InvalidWayOfUsingAnalysisSession::class)
-public inline fun <R> analyse(
-    contextElement: KtElement,
-    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
-    action: KtAnalysisSession.() -> R
-): R =
-    KtAnalysisSessionProvider.getInstance(contextElement.project)
-        .analyse(contextElement, nonDefaultLifetimeTokenFactory, action)
-
-
-@OptIn(InvalidWayOfUsingAnalysisSession::class)
-public inline fun <R> analyze(
-    ktModule: KtModule,
-    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
-    crossinline action: KtAnalysisSession.() -> R
-): R {
-    checkNotNull(ktModule.project)
-    val sessionProvider = KtAnalysisSessionProvider.getInstance(ktModule.project!!)
-    return sessionProvider.analyze(ktModule, nonDefaultLifetimeTokenFactory, action)
-}
-
-@OptIn(InvalidWayOfUsingAnalysisSession::class)
-public inline fun <R> analyseInDependedAnalysisSession(
-    originalFile: KtFile,
-    elementToReanalyze: KtElement,
-    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
-    action: KtAnalysisSession.() -> R
-): R =
-    KtAnalysisSessionProvider.getInstance(originalFile.project)
-        .analyseInDependedAnalysisSession(originalFile, elementToReanalyze, nonDefaultLifetimeTokenFactory, action)
-
-/**
- * Execute given [action] in [KtAnalysisSession] context like [analyse] does but execute it in read action
- * Uses [contextElement] to get a module from which you would like to see the other modules
- * Usually [contextElement] is some element form the module you currently analysing now
- *
- * Should be called from read action
- * To analyse something from EDT thread, consider using [analyseInModalWindow]
- * If you are already in read action, consider using [analyse]
- *
- * @see KtAnalysisSession
- * @see analyse
- */
-public inline fun <R> analyseWithReadAction(
-    contextElement: KtElement,
-    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
-    crossinline action: KtAnalysisSession.() -> R
-): R = ApplicationManager.getApplication().runReadAction(Computable {
-    analyse(contextElement, nonDefaultLifetimeTokenFactory, action)
-})
-
-/**
- * Show a modal window with a progress bar and specified [windowTitle]
- * and execute given [action] task with [KtAnalysisSession] context
- * If [action] throws some exception, then [analyseInModalWindow] will rethrow it
- * Should be executed from EDT only
- * If you want to analyse something from non-EDT thread, consider using [analyse]/[analyseWithReadAction]
- */
-public inline fun <R> analyseInModalWindow(
-    contextElement: KtElement,
-    windowTitle: String,
-    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
-    crossinline action: KtAnalysisSession.() -> R
-): R {
-    ApplicationManager.getApplication().assertIsDispatchThread()
-    val task = object : Task.WithResult<R, Exception>(contextElement.project, windowTitle, /*canBeCancelled*/ true) {
-        override fun compute(indicator: ProgressIndicator): R =
-            analyseWithReadAction(contextElement, nonDefaultLifetimeTokenFactory) { action() }
-    }
-    task.queue()
-    return task.result
-}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/KtAnalysisSessionProvider.kt

@@ -0,0 +1,121 @@
+/*
+ * 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.session
+
+import com.intellij.openapi.Disposable
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.project.Project
+import org.jetbrains.annotations.TestOnly
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.KtInternalApiMarker
+import org.jetbrains.kotlin.analysis.api.NoWriteActionInAnalyseCallChecker
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
+import org.jetbrains.kotlin.analysis.api.tokens.KtLifetimeTokenFactory
+import org.jetbrains.kotlin.analysis.project.structure.KtModule
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+
+@RequiresOptIn("To use analysis session, consider using analyze/analyzeWithReadAction/analyseInModalWindow methods")
+public annotation class InvalidWayOfUsingAnalysisSession
+
+@RequiresOptIn
+public annotation class KtAnalysisSessionProviderInternals
+
+/**
+ * Provides [KtAnalysisSession] by [contextElement]
+ * Should not be used directly, consider using [analyse]/[analyzeWithReadAction]/[analyzeInModalWindow] instead
+ */
+@InvalidWayOfUsingAnalysisSession
+public abstract class KtAnalysisSessionProvider(public val project: Project) : Disposable {
+
+    @Suppress("LeakingThis")
+    @OptIn(KtInternalApiMarker::class)
+    public val noWriteActionInAnalyseCallChecker: NoWriteActionInAnalyseCallChecker = NoWriteActionInAnalyseCallChecker(this)
+
+    @InvalidWayOfUsingAnalysisSession
+    public abstract fun getAnalysisSession(useSiteKtElement: KtElement, factory: KtLifetimeTokenFactory): KtAnalysisSession
+
+    @InvalidWayOfUsingAnalysisSession
+    public abstract fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession
+
+    @InvalidWayOfUsingAnalysisSession
+    public abstract fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession
+
+    @InvalidWayOfUsingAnalysisSession
+    public inline fun <R> analyzeWithSymbolAsContext(
+        contextSymbol: KtSymbol,
+        action: KtAnalysisSession.() -> R
+    ): R {
+        val analysisSession = getAnalysisSessionBySymbol(contextSymbol)
+        return action(analysisSession)
+    }
+
+    @InvalidWayOfUsingAnalysisSession
+    public inline fun <R> analyseInDependedAnalysisSession(
+        originalFile: KtFile,
+        elementToReanalyze: KtElement,
+        nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory?,
+        action: KtAnalysisSession.() -> R
+    ): R {
+        val factory =
+            nonDefaultLifetimeTokenFactory ?: KtDefaultLifetimeTokenProvider.getService(project).getDefaultLifetimeTokenFactory()
+
+        val originalAnalysisSession = getAnalysisSession(originalFile, factory)
+        val dependedAnalysisSession = originalAnalysisSession
+            .createContextDependentCopy(originalFile, elementToReanalyze)
+        return analyse(dependedAnalysisSession, factory, action)
+    }
+
+    @InvalidWayOfUsingAnalysisSession
+    public inline fun <R> analyse(
+        useSiteKtElement: KtElement,
+        nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory?,
+        action: KtAnalysisSession.() -> R
+    ): R {
+        val factory =
+            nonDefaultLifetimeTokenFactory ?: KtDefaultLifetimeTokenProvider.getService(project).getDefaultLifetimeTokenFactory()
+        return analyse(getAnalysisSession(useSiteKtElement, factory), factory, action)
+    }
+
+    @InvalidWayOfUsingAnalysisSession
+    public inline fun <R> analyze(
+        useSiteKtModule: KtModule,
+        nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory?,
+        action: KtAnalysisSession.() -> R
+    ): R {
+        val factory =
+            nonDefaultLifetimeTokenFactory ?: KtDefaultLifetimeTokenProvider.getService(project).getDefaultLifetimeTokenFactory()
+
+        return analyse(getAnalysisSessionByUseSiteKtModule(useSiteKtModule, factory), factory, action)
+    }
+
+    @OptIn(KtAnalysisSessionProviderInternals::class, KtInternalApiMarker::class)
+    @InvalidWayOfUsingAnalysisSession
+    public inline fun <R> analyse(
+        analysisSession: KtAnalysisSession,
+        factory: KtLifetimeTokenFactory,
+        action: KtAnalysisSession.() -> R
+    ): R {
+        noWriteActionInAnalyseCallChecker.beforeEnteringAnalysisContext()
+        factory.beforeEnteringAnalysisContext()
+        return try {
+            analysisSession.action()
+        } finally {
+            factory.afterLeavingAnalysisContext()
+            noWriteActionInAnalyseCallChecker.afterLeavingAnalysisContext()
+        }
+    }
+
+    @TestOnly
+    public abstract fun clearCaches()
+
+    override fun dispose() {}
+
+    public companion object {
+        public fun getInstance(project: Project): KtAnalysisSessionProvider =
+            ServiceManager.getService(project, KtAnalysisSessionProvider::class.java)
+    }
+}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/analyze.kt

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.session
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.progress.ProgressIndicator
+import com.intellij.openapi.progress.Task
+import com.intellij.openapi.util.Computable
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.tokens.KtLifetimeTokenFactory
+import org.jetbrains.kotlin.analysis.project.structure.KtModule
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFile
+
+/**
+ * Execute given [action] in [KtAnalysisSession] context
+ * Uses [useSiteKtElement] to get a module from which you would like to see the other modules
+ * Usually [useSiteKtElement] is some element form the module you currently analysing now
+ *
+ * Should not be called from EDT thread
+ * Should be called from read action
+ * To analyse something from EDT thread, consider using [analyzeInModalWindow]
+ *
+ * @see KtAnalysisSession
+ * @see analyzeWithReadAction
+ */
+@OptIn(InvalidWayOfUsingAnalysisSession::class)
+public inline fun <R> analyze(
+    useSiteKtElement: KtElement,
+    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
+    action: KtAnalysisSession.() -> R
+): R =
+    KtAnalysisSessionProvider.getInstance(useSiteKtElement.project)
+        .analyse(useSiteKtElement, nonDefaultLifetimeTokenFactory, action)
+
+
+@OptIn(InvalidWayOfUsingAnalysisSession::class)
+public inline fun <R> analyze(
+    ktModule: KtModule,
+    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
+    crossinline action: KtAnalysisSession.() -> R
+): R {
+    checkNotNull(ktModule.project)
+    val sessionProvider = KtAnalysisSessionProvider.getInstance(ktModule.project!!)
+    return sessionProvider.analyze(ktModule, nonDefaultLifetimeTokenFactory, action)
+}
+
+
+
+@OptIn(InvalidWayOfUsingAnalysisSession::class)
+public inline fun <R> analyzeInDependedAnalysisSession(
+    originalFile: KtFile,
+    elementToReanalyze: KtElement,
+    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
+    action: KtAnalysisSession.() -> R
+): R =
+    KtAnalysisSessionProvider.getInstance(originalFile.project)
+        .analyseInDependedAnalysisSession(originalFile, elementToReanalyze, nonDefaultLifetimeTokenFactory, action)
+
+/**
+ * Execute given [action] in [KtAnalysisSession] context like [analyze] does but execute it in read action
+ * Uses [contextElement] to get a module from which you would like to see the other modules
+ * Usually [contextElement] is some element form the module you currently analysing now
+ *
+ * Should be called from read action
+ * To analyse something from EDT thread, consider using [analyzeInModalWindow]
+ * If you are already in read action, consider using [analyze]
+ *
+ * @see KtAnalysisSession
+ * @see analyze
+ */
+public inline fun <R> analyzeWithReadAction(
+    contextElement: KtElement,
+    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
+    crossinline action: KtAnalysisSession.() -> R
+): R = ApplicationManager.getApplication().runReadAction(Computable {
+    analyze(contextElement, nonDefaultLifetimeTokenFactory, action)
+})
+
+/**
+ * Show a modal window with a progress bar and specified [windowTitle]
+ * and execute given [action] task with [KtAnalysisSession] context
+ * If [action] throws some exception, then [analyzeInModalWindow] will rethrow it
+ * Should be executed from EDT only
+ * If you want to analyse something from non-EDT thread, consider using [analyze]/[analyzeWithReadAction]
+ */
+public inline fun <R> analyzeInModalWindow(
+    contextElement: KtElement,
+    windowTitle: String,
+    nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null,
+    crossinline action: KtAnalysisSession.() -> R
+): R {
+    ApplicationManager.getApplication().assertIsDispatchThread()
+    val task = object : Task.WithResult<R, Exception>(contextElement.project, windowTitle, /*canBeCancelled*/ true) {
+        override fun compute(indicator: ProgressIndicator): R =
+            analyzeWithReadAction(contextElement, nonDefaultLifetimeTokenFactory) { action() }
+    }
+    task.queue()
+    return task.result
+}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/tokens/KtReadActionConfinementLifetimeToken.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
 import org.jetbrains.kotlin.analysis.api.*
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import kotlin.reflect.KClass
 
 public class KtReadActionConfinementLifetimeToken(project: Project) : KtLifetimeToken() {

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

@@ -5,28 +5,24 @@
 
 package org.jetbrains.kotlin.analysis.test.framework.base
 
-import com.intellij.mock.MockProject
 import com.intellij.openapi.util.Disposer
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.testFramework.TestDataFile
 import junit.framework.ComparisonFailure
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.session.analyze
-import org.jetbrains.kotlin.analysis.api.analyseInDependedAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.analyzeInDependedAnalysisSession
-import org.jetbrains.kotlin.analysis.api.*
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.test.framework.AnalysisApiTestDirectives
 import org.jetbrains.kotlin.analysis.test.framework.TestWithDisposable
 import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.ExpressionMarkerProvider
 import org.jetbrains.kotlin.analysis.test.framework.services.ExpressionMarkersSourceFilePreprocessor
-import org.jetbrains.kotlin.analysis.test.framework.services.libraries.LibraryWasNotCompiledDueToExpectedCompilationError
 import org.jetbrains.kotlin.analysis.test.framework.test.configurators.AnalysisApiTestConfigurator
 import org.jetbrains.kotlin.analysis.test.framework.utils.SkipTestException
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.test.ExecutionListenerBasedDisposableProvider
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.TestConfiguration
 import org.jetbrains.kotlin.test.TestInfrastructureInternals
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
@@ -37,8 +33,6 @@ import org.jetbrains.kotlin.test.model.FrontendKinds
 import org.jetbrains.kotlin.test.model.ResultingArtifact
 import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerTest
 import org.jetbrains.kotlin.test.services.*
-import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator
-import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.impl.TemporaryDirectoryManagerImpl
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.TestInfo
@@ -171,13 +165,13 @@ abstract class AbstractAnalysisApiBasedTest : TestWithDisposable() {
         return if (configurator.analyseInDependentSession) {
             val originalContainingFile = contextElement.containingKtFile
             val fileCopy = originalContainingFile.copy() as KtFile
-            analyseInDependedAnalysisSession(
+            analyzeInDependedAnalysisSession(
                 originalContainingFile,
                 PsiTreeUtil.findSameElementInCopy(contextElement, fileCopy),
                 action = action
             )
         } else {
-            analyse(contextElement, action = action)
+            analyze(contextElement, action = action)
         }
     }
 

analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/utils/commonTestUtils.kt

@@ -10,8 +10,6 @@ import com.intellij.openapi.util.Computable
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.psi.impl.source.resolve.reference.impl.PsiMultiReference
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.analyse
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils.offsetToLineAndColumn
 import org.jetbrains.kotlin.idea.references.KtReference

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

@@ -9,8 +9,8 @@ import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.impl.PsiElementFinderImpl
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.light.classes.symbol.classes
 
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.analyse
+import org.jetbrains.kotlin.analysis.api.session.analyze
 import org.jetbrains.kotlin.analysis.api.tokens.KtAlwaysAccessibleLifetimeTokenFactory
 import org.jetbrains.kotlin.psi.KtElement
 
 internal inline fun <R> analyseForLightClasses(context: KtElement, action: KtAnalysisSession.() -> R): R =
-    analyse(context, KtAlwaysAccessibleLifetimeTokenFactory, action)
+    analyze(context, KtAlwaysAccessibleLifetimeTokenFactory, action)

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt

@@ -9,9 +9,9 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiType
-import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
+import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
+import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.HackToForceAllowRunningAnalyzeOnEDT
 import org.jetbrains.kotlin.analysis.api.tokens.hackyAllowRunningOnEdt