From eb9085c083797cbeef080ab8cd37b8a384988078 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Tue, 10 May 2022 16:53:30 +0200 Subject: [PATCH] [analysis api] rename analyse -> analyze to match American word spelling --- .../KtFe10CliAnalysisSessionProvider.kt | 10 +- .../base/KtFe10PolyVariantResolver.kt | 4 +- .../AnalysisApiFe10TestServiceRegistrar.kt | 4 +- .../analysis/api/fir/KtFirAnalysisSession.kt | 2 +- .../api/fir/KtFirAnalysisSessionProvider.kt | 2 +- .../fir/references/KtFirReferenceResolver.kt | 4 +- .../KtAnalysisSessionFe10BindingHolder.kt | 2 +- .../base/CachingKtAnalysisSessionProvider.kt | 8 +- ...nalysisApiExpressionPsiTypeProviderTest.kt | 4 +- .../AbstractAnalysisApiPsiTypeProviderTest.kt | 4 +- .../AbstractAnalysisApiGetSuperTypesTest.kt | 4 +- .../api/standalone/StandaloneModeUtils.kt | 4 +- .../analysis/api/KtAnalysisSessionProvider.kt | 208 ------------------ .../api/session/KtAnalysisSessionProvider.kt | 121 ++++++++++ .../kotlin/analysis/api/session/analyze.kt | 103 +++++++++ .../KtReadActionConfinementLifetimeToken.kt | 1 + .../base/AbstractAnalysisApiBasedTest.kt | 16 +- .../test/framework/utils/commonTestUtils.kt | 2 - .../AnalysisApiFirTestServiceRegistrar.kt | 4 +- .../symbol/classes/analyseForLightClasses.kt | 4 +- .../light/classes/symbol/lightClassUtils.kt | 4 +- 21 files changed, 262 insertions(+), 253 deletions(-) delete mode 100644 analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSessionProvider.kt create mode 100644 analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/KtAnalysisSessionProvider.kt create mode 100644 analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/analyze.kt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt index eb8301fdb9c..282e07585e9 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt +++ b/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 { - return KtFe10AnalysisSession(contextElement, factory.create(contextElement.project)) + override fun getAnalysisSession(useSiteKtElement: KtElement, factory: KtLifetimeTokenFactory): KtAnalysisSession { + 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") } diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt index 9280181757d..9b8093e4366 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/base/KtFe10PolyVariantResolver.kt +++ b/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 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) { diff --git a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/test/configurator/AnalysisApiFe10TestServiceRegistrar.kt b/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/test/configurator/AnalysisApiFe10TestServiceRegistrar.kt index 5390877d8a3..ab23883bd94 100644 --- a/analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/test/configurator/AnalysisApiFe10TestServiceRegistrar.kt +++ b/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.KtAnalysisSessionProvider +import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession +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 diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt index 0de1e1657bf..b044da1624a 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt +++ b/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.* diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt index d0b8926791b..da64ce16e04 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt +++ b/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 diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirReferenceResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirReferenceResolver.kt index 80cf14d47a2..31a418ab38a 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirReferenceResolver.kt +++ b/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 { @@ -25,7 +25,7 @@ object KtFirReferenceResolver : ResolveCache.PolyVariantResolver { 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 diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt index 265bab66cb6..bddf244efde 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt +++ b/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 diff --git a/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/CachingKtAnalysisSessionProvider.kt b/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/CachingKtAnalysisSessionProvider.kt index 36893f6db0a..4e62dd7a1fe 100644 --- a/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/CachingKtAnalysisSessionProvider.kt +++ b/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(project: Project) : } } - final override fun getAnalysisSessionByUseSiteKtModule(ktModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession { - val firResolveSession = getFirResolveSession(ktModule) + final override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule, factory: KtLifetimeTokenFactory): KtAnalysisSession { + val firResolveSession = getFirResolveSession(useSiteKtModule) return cache.getAnalysisSession(firResolveSession to factory.identifier) { val validityToken = factory.create(project) createAnalysisSession(firResolveSession, validityToken) diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiExpressionPsiTypeProviderTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiExpressionPsiTypeProviderTest.kt index 0667572f1b2..ac9ca6ac517 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiExpressionPsiTypeProviderTest.kt +++ b/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) diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiPsiTypeProviderTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiPsiTypeProviderTest.kt index cc81d461780..a58a4d049b5 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/psiTypeProvider/AbstractAnalysisApiPsiTypeProviderTest.kt +++ b/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)}") diff --git a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt b/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt index 3b723d1782e..a591a289f13 100644 --- a/analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/typeProvider/AbstractAnalysisApiGetSuperTypesTest.kt +++ b/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) diff --git a/analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeUtils.kt b/analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeUtils.kt index 66a462f1bc6..7136def7cd5 100644 --- a/analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeUtils.kt +++ b/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.KtAnalysisSessionProvider +import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession +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 diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSessionProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSessionProvider.kt deleted file mode 100644 index 86f9ecc3fbb..00000000000 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSessionProvider.kt +++ /dev/null @@ -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 analyzeWithSymbolAsContext( - contextSymbol: KtSymbol, - action: KtAnalysisSession.() -> R - ): R { - val analysisSession = getAnalysisSessionBySymbol(contextSymbol) - return action(analysisSession) - } - - @InvalidWayOfUsingAnalysisSession - public inline fun 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 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 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 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 analyse( - contextElement: KtElement, - nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null, - action: KtAnalysisSession.() -> R -): R = - KtAnalysisSessionProvider.getInstance(contextElement.project) - .analyse(contextElement, nonDefaultLifetimeTokenFactory, action) - - -@OptIn(InvalidWayOfUsingAnalysisSession::class) -public inline fun 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 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 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 analyseInModalWindow( - contextElement: KtElement, - windowTitle: String, - nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null, - crossinline action: KtAnalysisSession.() -> R -): R { - ApplicationManager.getApplication().assertIsDispatchThread() - val task = object : Task.WithResult(contextElement.project, windowTitle, /*canBeCancelled*/ true) { - override fun compute(indicator: ProgressIndicator): R = - analyseWithReadAction(contextElement, nonDefaultLifetimeTokenFactory) { action() } - } - task.queue() - return task.result -} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/KtAnalysisSessionProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/KtAnalysisSessionProvider.kt new file mode 100644 index 00000000000..1b7cdc11517 --- /dev/null +++ b/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 analyzeWithSymbolAsContext( + contextSymbol: KtSymbol, + action: KtAnalysisSession.() -> R + ): R { + val analysisSession = getAnalysisSessionBySymbol(contextSymbol) + return action(analysisSession) + } + + @InvalidWayOfUsingAnalysisSession + public inline fun 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 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 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 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) + } +} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/analyze.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/session/analyze.kt new file mode 100644 index 00000000000..94593acba02 --- /dev/null +++ b/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 analyze( + useSiteKtElement: KtElement, + nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null, + action: KtAnalysisSession.() -> R +): R = + KtAnalysisSessionProvider.getInstance(useSiteKtElement.project) + .analyse(useSiteKtElement, nonDefaultLifetimeTokenFactory, action) + + +@OptIn(InvalidWayOfUsingAnalysisSession::class) +public inline fun 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 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 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 analyzeInModalWindow( + contextElement: KtElement, + windowTitle: String, + nonDefaultLifetimeTokenFactory: KtLifetimeTokenFactory? = null, + crossinline action: KtAnalysisSession.() -> R +): R { + ApplicationManager.getApplication().assertIsDispatchThread() + val task = object : Task.WithResult(contextElement.project, windowTitle, /*canBeCancelled*/ true) { + override fun compute(indicator: ProgressIndicator): R = + analyzeWithReadAction(contextElement, nonDefaultLifetimeTokenFactory) { action() } + } + task.queue() + return task.result +} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/tokens/KtReadActionConfinementLifetimeToken.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/tokens/KtReadActionConfinementLifetimeToken.kt index 9b4d948582c..c9df536bb1c 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/tokens/KtReadActionConfinementLifetimeToken.kt +++ b/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() { diff --git a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt b/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt index ceb687e0256..c92551632ff 100644 --- a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/base/AbstractAnalysisApiBasedTest.kt +++ b/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.analyseInDependedAnalysisSession -import org.jetbrains.kotlin.analysis.api.* +import org.jetbrains.kotlin.analysis.api.session.analyze +import org.jetbrains.kotlin.analysis.api.session.analyzeInDependedAnalysisSession +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) } } diff --git a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/utils/commonTestUtils.kt b/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/utils/commonTestUtils.kt index f73a768395c..462f9e5439b 100644 --- a/analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/utils/commonTestUtils.kt +++ b/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 diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/AnalysisApiFirTestServiceRegistrar.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/AnalysisApiFirTestServiceRegistrar.kt index 67849b10e5c..38458be2f22 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/AnalysisApiFirTestServiceRegistrar.kt +++ b/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.KtAnalysisSessionProvider +import org.jetbrains.kotlin.analysis.api.session.InvalidWayOfUsingAnalysisSession +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 diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt index 2b93d95118d..7bee3cb0c62 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/analyseForLightClasses.kt +++ b/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 analyseForLightClasses(context: KtElement, action: KtAnalysisSession.() -> R): R = - analyse(context, KtAlwaysAccessibleLifetimeTokenFactory, action) \ No newline at end of file + analyze(context, KtAlwaysAccessibleLifetimeTokenFactory, action) \ No newline at end of file diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt index c361ce74de6..8047da35da6 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/lightClassUtils.kt +++ b/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