diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt
index 24f3eb36f5f..b8c62c645f3 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt
@@ -5,14 +5,23 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors
 
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 
 interface Fe10AnalysisFacade {
+    companion object {
+        fun getInstance(project: Project): Fe10AnalysisFacade {
+            return ServiceManager.getService(project, Fe10AnalysisFacade::class.java)
+        }
+    }
+
     fun getResolveSession(element: KtElement): ResolveSession
     fun getDeprecationResolver(element: KtElement): DeprecationResolver
 
@@ -25,4 +34,13 @@ interface Fe10AnalysisFacade {
         PARTIAL_WITH_DIAGNOSTICS,
         PARTIAL
     }
+}
+
+class Fe10AnalysisContext(
+    facade: Fe10AnalysisFacade,
+    contextElement: KtElement,
+    val token: ValidityToken
+) : Fe10AnalysisFacade by facade {
+    val resolveSession: ResolveSession = getResolveSession(contextElement)
+    val deprecationResolver: DeprecationResolver = getDeprecationResolver(contextElement)
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt
index 2542b1919b8..f03b9f80020 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt
@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors
 
-import com.intellij.openapi.components.ServiceManager
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.components.*
 import org.jetbrains.kotlin.analysis.api.descriptors.components.*
@@ -13,13 +12,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProvider
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.resolve.deprecation.DeprecationResolver
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 
 @Suppress("LeakingThis")
-class KtFe10AnalysisSession(
-    private val contextElement: KtElement, token: ValidityToken
-) : KtAnalysisSession(token), Fe10AnalysisFacade by ServiceManager.getService(contextElement.project, Fe10AnalysisFacade::class.java) {
+class KtFe10AnalysisSession(val analysisContext: Fe10AnalysisContext) : KtAnalysisSession(analysisContext.token) {
+    constructor(contextElement: KtElement, token: ValidityToken) :
+            this(Fe10AnalysisContext(Fe10AnalysisFacade.getInstance(contextElement.project), contextElement, token))
+
     override val smartCastProviderImpl: KtSmartCastProvider = KtFe10SmartCastProvider(this)
     override val diagnosticProviderImpl: KtDiagnosticProvider = KtFe10DiagnosticProvider(this)
     override val scopeProviderImpl: KtScopeProvider = KtFe10ScopeProvider(this)
@@ -46,9 +44,6 @@ class KtFe10AnalysisSession(
     override val jvmTypeMapperImpl: KtJvmTypeMapper = KtFe10JvmTypeMapper(this)
     override val symbolInfoProviderImpl: KtSymbolInfoProvider = KtFe10SymbolInfoProvider(this)
 
-    val resolveSession: ResolveSession = getResolveSession(contextElement)
-    val deprecationResolver: DeprecationResolver = getDeprecationResolver(contextElement)
-
     override fun createContextDependentCopy(originalKtFile: KtFile, elementToReanalyze: KtElement): KtAnalysisSession {
         return KtFe10AnalysisSession(elementToReanalyze, token)
     }
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 113a972be44..f05234e36ce 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
@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityTokenFactory
 import org.jetbrains.kotlin.psi.KtElement
+import java.lang.UnsupportedOperationException
 
 @InvalidWayOfUsingAnalysisSession
 class KtFe10AnalysisSessionProvider : KtAnalysisSessionProvider() {
@@ -23,7 +24,7 @@ class KtFe10AnalysisSessionProvider : KtAnalysisSessionProvider() {
     @InvalidWayOfUsingAnalysisSession
     override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession {
         if (contextSymbol is KtFe10Symbol) {
-            return contextSymbol.analysisSession
+            return KtFe10AnalysisSession(contextSymbol.analysisContext)
         } else {
             val contextElement = contextSymbol.psi
             if (contextElement is KtElement) {
@@ -31,7 +32,7 @@ class KtFe10AnalysisSessionProvider : KtAnalysisSessionProvider() {
             }
         }
 
-        throw IllegalArgumentException("Unsupported symbol kind: $contextSymbol")
+        throw UnsupportedOperationException("getAnalysisSessionBySymbol() should not be used on KtFe10AnalysisSession")
     }
 
     override fun clearCaches() {}
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CallResolver.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CallResolver.kt
index d7f9933a9f5..6fe0b970e1c 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CallResolver.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CallResolver.kt
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 import org.jetbrains.kotlin.analysis.api.calls.*
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescPropertyGetterSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescPropertySetterSymbol
@@ -33,7 +34,9 @@ import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.isAnnotationConstructor
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 
-internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSession) : AbstractKtCallResolver() {
+internal class KtFe10CallResolver(
+    override val analysisSession: KtFe10AnalysisSession
+) : AbstractKtCallResolver(), Fe10KtAnalysisSessionComponent {
     private companion object {
         private const val UNRESOLVED_CALL_MESSAGE = "Unresolved call"
     }
@@ -42,7 +45,7 @@ internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSe
         get() = analysisSession.token
 
     override fun resolveAccessorCall(call: KtSimpleNameExpression): KtCall? {
-        val bindingContext = analysisSession.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+        val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
         val resolvedCall = call.getResolvedCall(bindingContext) ?: return null
         val resultingDescriptor = resolvedCall.resultingDescriptor
 
@@ -56,15 +59,15 @@ internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSe
             val accessorSymbol = when (resultingDescriptor) {
                 is SyntheticJavaPropertyDescriptor -> {
                     when {
-                        access.isWrite -> resultingDescriptor.setMethod?.let { KtFe10DescFunctionSymbol(it, analysisSession) }
-                        access.isRead -> KtFe10DescFunctionSymbol(resultingDescriptor.getMethod, analysisSession)
+                        access.isWrite -> resultingDescriptor.setMethod?.let { KtFe10DescFunctionSymbol(it, analysisContext) }
+                        access.isRead -> KtFe10DescFunctionSymbol(resultingDescriptor.getMethod, analysisContext)
                         else -> null
                     }
                 }
                 else -> {
                     when {
-                        access.isWrite -> resultingDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisSession) }
-                        access.isRead -> resultingDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisSession) }
+                        access.isWrite -> resultingDescriptor.setter?.let { KtFe10DescPropertySetterSymbol(it, analysisContext) }
+                        access.isRead -> resultingDescriptor.getter?.let { KtFe10DescPropertyGetterSymbol(it, analysisContext) }
                         else -> null
                     }
                 }
@@ -115,7 +118,7 @@ internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSe
      * @param isUsualCall `true` if the call is a usual function call (`foo()` or `foo {}`).
      */
     private fun resolveCall(call: KtElement, isUsualCall: Boolean): KtCall? {
-        val bindingContext = analysisSession.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+        val bindingContext = analysisContext.analyze(call, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
         val resolvedCall = call.getResolvedCall(bindingContext) ?: return getUnresolvedCall(call)
 
         val argumentMapping = createArgumentMapping(resolvedCall)
@@ -131,11 +134,11 @@ internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSe
 
         val targetDescriptor = resolvedCall.resultingDescriptor
 
-        val callableSymbol = targetDescriptor.toKtCallableSymbol(analysisSession) as? KtFunctionLikeSymbol ?: return null
+        val callableSymbol = targetDescriptor.toKtCallableSymbol(analysisContext) as? KtFunctionLikeSymbol ?: return null
 
         if (resolvedCall is VariableAsFunctionResolvedCall) {
             val variableDescriptor = resolvedCall.variableCall.resultingDescriptor
-            val variableSymbol = variableDescriptor.toKtCallableSymbol(analysisSession) as? KtVariableLikeSymbol ?: return null
+            val variableSymbol = variableDescriptor.toKtCallableSymbol(analysisContext) as? KtVariableLikeSymbol ?: return null
 
             val substitutor = KtSubstitutor.Empty(token)
             return if (resolvedCall.functionCall.resultingDescriptor.callableId in kotlinFunctionInvokeCallableIds) {
@@ -183,7 +186,7 @@ internal class KtFe10CallResolver(override val analysisSession: KtFe10AnalysisSe
     private fun createArgumentMapping(resolvedCall: ResolvedCall<*>): LinkedHashMap<KtExpression, KtValueParameterSymbol> {
         val result = LinkedHashMap<KtExpression, KtValueParameterSymbol>()
         for ((parameter, arguments) in resolvedCall.valueArguments) {
-            val parameterSymbol = KtFe10DescValueParameterSymbol(parameter, analysisSession)
+            val parameterSymbol = KtFe10DescValueParameterSymbol(parameter, analysisContext)
 
             for (argument in arguments.arguments) {
                 val expression = argument.getArgumentExpression() ?: continue
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt
index 252402345a0..e6a4effaff4 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtCompileTimeConstantProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
@@ -15,19 +16,21 @@ import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.types.TypeUtils
 
-internal class KtFe10CompileTimeConstantProvider(override val analysisSession: KtFe10AnalysisSession) : KtCompileTimeConstantProvider() {
+internal class KtFe10CompileTimeConstantProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtCompileTimeConstantProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun evaluate(expression: KtExpression): KtConstantValue? {
-        val resolveSession = analysisSession.resolveSession
+        val resolveSession = analysisContext.resolveSession
         val evaluator = ConstantExpressionEvaluator(
             resolveSession.moduleDescriptor,
             resolveSession.languageVersionSettings,
             resolveSession.project
         )
 
-        val bindingContext = analysisSession.analyze(expression)
+        val bindingContext = analysisContext.analyze(expression)
         val bindingTrace = DelegatingBindingTrace(bindingContext, "Binding trace for constant expression evaluation")
         return evaluator.evaluateToConstantValue(expression, bindingTrace, TypeUtils.NO_EXPECTED_TYPE)?.toKtConstantValue()
     }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompletionCandidateChecker.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompletionCandidateChecker.kt
index 4562ccd5228..38ac97d2f09 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompletionCandidateChecker.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompletionCandidateChecker.kt
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 import org.jetbrains.kotlin.analysis.api.components.KtCompletionCandidateChecker
 import org.jetbrains.kotlin.analysis.api.components.KtExtensionApplicabilityResult
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
@@ -15,7 +16,9 @@ import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtSimpleNameExpression
 
-internal class KtFe10CompletionCandidateChecker(override val analysisSession: KtFe10AnalysisSession) : KtCompletionCandidateChecker() {
+internal class KtFe10CompletionCandidateChecker(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtCompletionCandidateChecker(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10DiagnosticProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10DiagnosticProvider.kt
index 40fc9f791f7..101d3b799fd 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10DiagnosticProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10DiagnosticProvider.kt
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtDiagnosticCheckerFilter
 import org.jetbrains.kotlin.analysis.api.components.KtDiagnosticProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
@@ -22,13 +23,15 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import kotlin.reflect.KClass
 
-internal class KtFe10DiagnosticProvider(override val analysisSession: KtFe10AnalysisSession) : KtDiagnosticProvider() {
+internal class KtFe10DiagnosticProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtDiagnosticProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun getDiagnosticsForElement(element: KtElement, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> {
         withValidityAssertion {
-            val bindingContext = analysisSession.analyze(element, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+            val bindingContext = analysisContext.analyze(element, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
             val diagnostics = bindingContext.diagnostics.forElement(element)
             return diagnostics.map { KtFe10Diagnostic(it, token) }
         }
@@ -36,7 +39,7 @@ internal class KtFe10DiagnosticProvider(override val analysisSession: KtFe10Anal
 
     override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> {
         withValidityAssertion {
-            val bindingContext = analysisSession.analyze(ktFile)
+            val bindingContext = analysisContext.analyze(ktFile)
             val result = mutableListOf<KtDiagnosticWithPsi<*>>()
             for (diagnostic in bindingContext.diagnostics) {
                 if (diagnostic.psiFile == ktFile) {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionInfoProvider.kt
index c76257029eb..6e5859379ec 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionInfoProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionInfoProvider.kt
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 import org.jetbrains.kotlin.analysis.api.components.KtExpressionInfoProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
@@ -18,19 +19,21 @@ import org.jetbrains.kotlin.psi.KtReturnExpression
 import org.jetbrains.kotlin.psi.KtWhenExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 
-internal class KtFe10ExpressionInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtExpressionInfoProvider() {
+internal class KtFe10ExpressionInfoProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtExpressionInfoProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? = withValidityAssertion {
-        val bindingContext = analysisSession.analyze(returnExpression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(returnExpression, AnalysisMode.PARTIAL)
         val targetLabel = returnExpression.getTargetLabel() ?: return null
         val labelTarget = bindingContext[BindingContext.LABEL_TARGET, targetLabel] as? KtDeclaration ?: return null
         return with(analysisSession) { labelTarget.getSymbol() as? KtCallableSymbol }
     }
 
     override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> = withValidityAssertion {
-        val bindingContext = analysisSession.analyze(whenExpression)
+        val bindingContext = analysisContext.analyze(whenExpression)
         return WhenChecker.getMissingCases(whenExpression, bindingContext)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt
index ccf05a12d0a..19078356ceb 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ExpressionTypeProvider.kt
@@ -9,6 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.components.KtExpressionTypeProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
@@ -35,7 +36,9 @@ import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.isError
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
 
-class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisSession) : KtExpressionTypeProvider() {
+class KtFe10ExpressionTypeProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtExpressionTypeProvider(), Fe10KtAnalysisSessionComponent {
     private companion object {
         val NON_EXPRESSION_CONTAINERS = arrayOf(
             KtImportDirective::class.java,
@@ -49,7 +52,7 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
         get() = analysisSession.token
 
     private val builtIns: KotlinBuiltIns
-        get() = analysisSession.resolveSession.moduleDescriptor.builtIns
+        get() = analysisContext.resolveSession.moduleDescriptor.builtIns
 
     override fun getKtExpressionType(expression: KtExpression): KtType? = withValidityAssertion {
         // Not sure if it's safe enough. In theory, some annotations on expressions might change its type
@@ -58,9 +61,9 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
             return null
         }
 
-        val bindingContext = analysisSession.analyze(unwrapped, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(unwrapped, AnalysisMode.PARTIAL)
         val kotlinType = expression.getType(bindingContext) ?: builtIns.unitType
-        return kotlinType.toKtType(analysisSession)
+        return kotlinType.toKtType(analysisContext)
     }
 
     override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion {
@@ -69,48 +72,48 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
             val typeReference = declaration.typeReference
 
             if (typeReference != null) {
-                val bindingContext = analysisSession.analyze(typeReference, AnalysisMode.PARTIAL)
+                val bindingContext = analysisContext.analyze(typeReference, AnalysisMode.PARTIAL)
                 val kotlinType = bindingContext[BindingContext.TYPE, typeReference]
                     ?: ErrorUtils.createErrorType("Return type \"${typeReference.text}\" cannot be resolved")
 
-                return kotlinType.toKtType(analysisSession)
+                return kotlinType.toKtType(analysisContext)
             }
         }
 
         if (declaration is KtFunction && declaration !is KtConstructor<*> && declaration.equalsToken != null) {
-            val bindingContext = analysisSession.analyze(declaration)
+            val bindingContext = analysisContext.analyze(declaration)
             val kotlinType = bindingContext[BindingContext.FUNCTION, declaration]?.returnType
                 ?: ErrorUtils.createErrorType("Implicit return type for function \"${declaration.name}\" cannot be resolved")
 
-            return kotlinType.toKtType(analysisSession)
+            return kotlinType.toKtType(analysisContext)
         }
 
         if (declaration is KtProperty) {
-            val bindingContext = analysisSession.analyze(declaration)
+            val bindingContext = analysisContext.analyze(declaration)
             val kotlinType = bindingContext[BindingContext.VARIABLE, declaration]?.returnType
                 ?: ErrorUtils.createErrorType("Implicit return type for property \"${declaration.name}\" cannot be resolved")
 
-            return kotlinType.toKtType(analysisSession)
+            return kotlinType.toKtType(analysisContext)
         }
 
         if (declaration is KtPropertyAccessor) {
-            val bindingContext = analysisSession.analyze(declaration)
+            val bindingContext = analysisContext.analyze(declaration)
             val kotlinType = bindingContext[BindingContext.PROPERTY_ACCESSOR, declaration]?.returnType
                 ?: ErrorUtils.createErrorType("Return type for property accessor \"${declaration.property.name}\" cannot be resolved")
 
-            return kotlinType.toKtType(analysisSession)
+            return kotlinType.toKtType(analysisContext)
         }
 
-        return builtIns.unitType.toKtType(analysisSession)
+        return builtIns.unitType.toKtType(analysisContext)
     }
 
     override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType = withValidityAssertion {
         val analysisMode = if (declaration.hasDeclaredReturnType()) AnalysisMode.PARTIAL else AnalysisMode.FULL
-        val bindingContext = analysisSession.analyze(declaration, analysisMode)
+        val bindingContext = analysisContext.analyze(declaration, analysisMode)
         val functionDescriptor = bindingContext[BindingContext.FUNCTION, declaration]
 
         if (functionDescriptor != null) {
-            return getFunctionTypeForAbstractMethod(functionDescriptor, false).toKtType(analysisSession)
+            return getFunctionTypeForAbstractMethod(functionDescriptor, false).toKtType(analysisContext)
         }
 
         val parameterCount = declaration.valueParameters.size + (if (declaration.isExtensionDeclaration()) 1 else 0)
@@ -121,7 +124,7 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
         }
 
         val errorMessage = "Descriptor not found for function \"${declaration.name}\""
-        return ErrorUtils.createErrorTypeWithCustomConstructor(errorMessage, function.typeConstructor).toKtType(analysisSession)
+        return ErrorUtils.createErrorTypeWithCustomConstructor(errorMessage, function.typeConstructor).toKtType(analysisContext)
     }
 
     override fun getExpectedType(expression: PsiElement): KtType? = withValidityAssertion {
@@ -145,25 +148,25 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
                 return null
             }
 
-            val bindingContext = analysisSession.analyze(parentExpression)
+            val bindingContext = analysisContext.analyze(parentExpression)
             val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, parentExpression]
             if (descriptor is CallableDescriptor) {
-                return descriptor.returnType?.takeIf { !it.isError }?.toKtType(analysisSession)
+                return descriptor.returnType?.takeIf { !it.isError }?.toKtType(analysisContext)
             }
         } else if (parentExpression is KtBinaryExpressionWithTypeRHS && KtPsiUtil.isCast(parentExpression)) {
             val typeReference = parentExpression.right
             if (typeReference != null) {
-                val bindingContext = analysisSession.analyze(typeReference)
+                val bindingContext = analysisContext.analyze(typeReference)
                 var kotlinType = bindingContext[BindingContext.TYPE, typeReference]
                 if (kotlinType != null && KtPsiUtil.isSafeCast(parentExpression)) {
                     kotlinType = kotlinType.makeNullable()
                 }
-                return kotlinType?.toKtType(analysisSession)
+                return kotlinType?.toKtType(analysisContext)
             }
         } else if (parentExpression is KtValueArgument) {
             val callExpression = getContainingCallExpression(parentExpression)
             if (callExpression != null) {
-                val bindingContext = analysisSession.analyze(callExpression)
+                val bindingContext = analysisContext.analyze(callExpression)
                 val resolvedCall = callExpression.getResolvedCall(bindingContext)
                 if (resolvedCall != null) {
                     val parameterDescriptor = resolvedCall.getParameterForArgument(parentExpression)?.original
@@ -172,15 +175,15 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
                             is SamConstructorDescriptor -> originalCallableDescriptor.returnTypeOrNothing
                             else -> parameterDescriptor.type
                         }
-                        return kotlinType.takeIf { !it.isError }?.toKtType(analysisSession)
+                        return kotlinType.takeIf { !it.isError }?.toKtType(analysisContext)
                     }
                 }
             }
         }
 
-        val bindingContext = analysisSession.analyze(ktExpression)
+        val bindingContext = analysisContext.analyze(ktExpression)
         val kotlinType = bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, ktExpression]
-        return kotlinType?.takeIf { !it.isError }?.toKtType(analysisSession)
+        return kotlinType?.takeIf { !it.isError }?.toKtType(analysisContext)
     }
 
     private fun getContainingCallExpression(argument: KtValueArgument): KtCallExpression? {
@@ -193,7 +196,7 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
 
     override fun isDefinitelyNull(expression: KtExpression): Boolean = withValidityAssertion {
         val unwrapped = expression.unwrapParenthesesLabelsAndAnnotations() as? KtElement ?: return false
-        val bindingContext = analysisSession.analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
 
         if (bindingContext[BindingContext.SMARTCAST_NULL, expression] == true) {
             return true
@@ -210,7 +213,7 @@ class KtFe10ExpressionTypeProvider(override val analysisSession: KtFe10AnalysisS
 
     override fun isDefinitelyNotNull(expression: KtExpression): Boolean = withValidityAssertion {
         val ktExpression = expression as? KtExpression ?: return false
-        val bindingContext = analysisSession.analyze(ktExpression)
+        val bindingContext = analysisContext.analyze(ktExpression)
 
         val smartCasts = bindingContext[BindingContext.SMARTCAST, ktExpression]
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ImportOptimizer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ImportOptimizer.kt
index 99b34a4eb20..dedd182534e 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ImportOptimizer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ImportOptimizer.kt
@@ -8,13 +8,16 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizer
 import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtImportDirective
 
-internal class KtFe10ImportOptimizer(private val analysisSession: KtFe10AnalysisSession) : KtImportOptimizer() {
+internal class KtFe10ImportOptimizer(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtImportOptimizer(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10InheritorsProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10InheritorsProvider.kt
index 64326a86895..102ae967a3a 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10InheritorsProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10InheritorsProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtInheritorsProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescEnumEntrySymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtClassifierSymbol
@@ -18,19 +19,21 @@ import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 
-internal class KtFe10InheritorsProvider(override val analysisSession: KtFe10AnalysisSession) : KtInheritorsProvider() {
+internal class KtFe10InheritorsProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtInheritorsProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun getInheritorsOfSealedClass(classSymbol: KtNamedClassOrObjectSymbol): List<KtNamedClassOrObjectSymbol> {
         val classDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
 
-        val inheritorsProvider = analysisSession.resolveSession.sealedClassInheritorsProvider
-        val allowInDifferentFiles = analysisSession.resolveSession.languageVersionSettings
+        val inheritorsProvider = analysisContext.resolveSession.sealedClassInheritorsProvider
+        val allowInDifferentFiles = analysisContext.resolveSession.languageVersionSettings
             .supportsFeature(LanguageFeature.AllowSealedInheritorsInDifferentFilesOfSamePackage)
 
         return inheritorsProvider.computeSealedSubclasses(classDescriptor, allowInDifferentFiles)
-            .mapNotNull { it.toKtClassifierSymbol(analysisSession) as? KtNamedClassOrObjectSymbol }
+            .mapNotNull { it.toKtClassifierSymbol(analysisContext) as? KtNamedClassOrObjectSymbol }
     }
 
     override fun getEnumEntries(classSymbol: KtNamedClassOrObjectSymbol): List<KtEnumEntrySymbol> = withValidityAssertion {
@@ -43,7 +46,7 @@ internal class KtFe10InheritorsProvider(override val analysisSession: KtFe10Anal
 
         for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) {
             if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) {
-                result += KtFe10DescEnumEntrySymbol(entryDescriptor, analysisSession)
+                result += KtFe10DescEnumEntrySymbol(entryDescriptor, analysisContext)
             }
         }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10JvmTypeMapper.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10JvmTypeMapper.kt
index b5756cd575b..39868214dc6 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10JvmTypeMapper.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10JvmTypeMapper.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtJvmTypeMapper
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10JvmTypeMapperContext
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
@@ -15,11 +16,13 @@ import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
 import org.jetbrains.org.objectweb.asm.Type
 
-internal class KtFe10JvmTypeMapper(override val analysisSession: KtFe10AnalysisSession) : KtJvmTypeMapper() {
+internal class KtFe10JvmTypeMapper(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtJvmTypeMapper(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
-    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisSession.resolveSession) }
+    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisContext.resolveSession) }
 
     override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type = withValidityAssertion {
         val kotlinType = (type as KtFe10Type).type
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt
index eb1acafff32..18f7e649121 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10OverrideInfoProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtOverrideInfoProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtClassifierSymbol
@@ -21,7 +22,9 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.resolve.findOriginalTopMostOverriddenDescriptors
 import org.jetbrains.kotlin.util.ImplementationStatus
 
-internal class KtFe10OverrideInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtOverrideInfoProvider() {
+internal class KtFe10OverrideInfoProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtOverrideInfoProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
@@ -41,13 +44,13 @@ internal class KtFe10OverrideInfoProvider(override val analysisSession: KtFe10An
     override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? = withValidityAssertion {
         val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null
         val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null
-        return originalCallableDescriptor.toKtCallableSymbol(analysisSession)
+        return originalCallableDescriptor.toKtCallableSymbol(analysisContext)
     }
 
     override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? = withValidityAssertion {
         val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null
         val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null
         val containingClassDescriptor = originalCallableDescriptor.containingDeclaration as? ClassDescriptor ?: return null
-        return containingClassDescriptor.toKtClassifierSymbol(analysisSession) as? KtClassOrObjectSymbol
+        return containingClassDescriptor.toKtClassifierSymbol(analysisContext) as? KtClassOrObjectSymbol
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt
index cca388e3481..3295649572a 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10PsiTypeProvider.kt
@@ -13,6 +13,7 @@ import com.intellij.psi.impl.compiled.SignatureParsing
 import com.intellij.psi.impl.compiled.StubBuildingVisitor
 import org.jetbrains.kotlin.analysis.api.components.KtPsiTypeProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10JvmTypeMapperContext
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
@@ -27,11 +28,13 @@ import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.types.*
 import java.text.StringCharacterIterator
 
-internal class KtFe10PsiTypeProvider(override val analysisSession: KtFe10AnalysisSession) : KtPsiTypeProvider() {
+internal class KtFe10PsiTypeProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtPsiTypeProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
-    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisSession.resolveSession) }
+    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisContext.resolveSession) }
 
     override fun asPsiType(
         type: KtType,
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceShortener.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceShortener.kt
index 81ee074b64c..67711ef43e1 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceShortener.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ReferenceShortener.kt
@@ -10,12 +10,15 @@ import org.jetbrains.kotlin.analysis.api.components.KtReferenceShortener
 import org.jetbrains.kotlin.analysis.api.components.ShortenCommand
 import org.jetbrains.kotlin.analysis.api.components.ShortenOption
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.psi.KtFile
 
-internal class KtFe10ReferenceShortener(override val analysisSession: KtFe10AnalysisSession) : KtReferenceShortener() {
+internal class KtFe10ReferenceShortener(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtReferenceShortener(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SamResolver.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SamResolver.kt
index 18f7e4cd20f..7af509e6b22 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SamResolver.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SamResolver.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtSamResolver
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescSamConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
@@ -18,7 +19,9 @@ import org.jetbrains.kotlin.load.java.sam.JvmSamConversionOracle
 import org.jetbrains.kotlin.resolve.sam.createSamConstructorFunction
 import org.jetbrains.kotlin.resolve.sam.getSingleAbstractMethodOrNull
 
-internal class KtFe10SamResolver(override val analysisSession: KtFe10AnalysisSession) : KtSamResolver() {
+internal class KtFe10SamResolver(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSamResolver(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
@@ -28,11 +31,11 @@ internal class KtFe10SamResolver(override val analysisSession: KtFe10AnalysisSes
             val constructorDescriptor = createSamConstructorFunction(
                 descriptor.containingDeclaration,
                 descriptor,
-                analysisSession.resolveSession.samConversionResolver,
-                JvmSamConversionOracle(analysisSession.resolveSession.languageVersionSettings)
+                analysisContext.resolveSession.samConversionResolver,
+                JvmSamConversionOracle(analysisContext.resolveSession.languageVersionSettings)
             )
 
-            return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisSession)
+            return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisContext)
         }
 
         return null
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ScopeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ScopeProvider.kt
index 4a9af229a89..9364e9713f6 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ScopeProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10ScopeProvider.kt
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtImplicitReceiver
 import org.jetbrains.kotlin.analysis.api.components.KtScopeContext
 import org.jetbrains.kotlin.analysis.api.components.KtScopeProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.scopes.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10FileSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
@@ -40,7 +41,9 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy
 import org.jetbrains.kotlin.util.containingNonLocalDeclaration
 
-internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisSession) : KtScopeProvider() {
+internal class KtFe10ScopeProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtScopeProvider(), Fe10KtAnalysisSessionComponent {
     private companion object {
         val LOG = Logger.getInstance(KtFe10ScopeProvider::class.java)
     }
@@ -53,7 +56,7 @@ internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisS
             ?: return getEmptyScope()
 
         // TODO either this or declared scope should return a different set of members
-        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisSession)
+        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisContext)
     }
 
     override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
@@ -61,7 +64,7 @@ internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisS
             ?: return getEmptyScope()
 
         // TODO: need to return declared members only
-        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisSession)
+        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisContext)
     }
 
     override fun getDelegatedMemberScope(classSymbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
@@ -69,12 +72,12 @@ internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisS
             ?: return getEmptyScope()
 
         // TODO: need to return delegated members only
-        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisSession)
+        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisContext)
     }
 
     override fun getStaticMemberScope(symbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
         val descriptor = getDescriptor<ClassDescriptor>(symbol) ?: return getEmptyScope()
-        return KtFe10ScopeMember(descriptor.staticScope, analysisSession)
+        return KtFe10ScopeMember(descriptor.staticScope, analysisContext)
     }
 
     override fun getEmptyScope(): KtScope = withValidityAssertion {
@@ -83,17 +86,17 @@ internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisS
 
     override fun getFileScope(fileSymbol: KtFileSymbol): KtScope = withValidityAssertion {
         require(fileSymbol is KtFe10FileSymbol)
-        val scope = analysisSession.resolveSession.fileScopeProvider.getFileResolutionScope(fileSymbol.psi)
+        val scope = analysisContext.resolveSession.fileScopeProvider.getFileResolutionScope(fileSymbol.psi)
 
-        return KtFe10ScopeLexical(scope, analysisSession)
+        return KtFe10ScopeLexical(scope, analysisContext)
     }
 
     override fun getPackageScope(packageSymbol: KtPackageSymbol): KtScope = withValidityAssertion {
         require(packageSymbol is KtFe10PackageSymbol)
-        val packageFragments = analysisSession.resolveSession.packageFragmentProvider.packageFragments(packageSymbol.fqName)
+        val packageFragments = analysisContext.resolveSession.packageFragmentProvider.packageFragments(packageSymbol.fqName)
         val scopeDescription = "Compound scope for package \"${packageSymbol.fqName}\""
         val chainedScope = ChainedMemberScope.create(scopeDescription, packageFragments.map { it.getMemberScope() })
-        return KtFe10PackageScope(chainedScope, packageSymbol, analysisSession)
+        return KtFe10PackageScope(chainedScope, packageSymbol, analysisContext)
     }
 
     override fun getCompositeScope(subScopes: List<KtScope>): KtScope = withValidityAssertion {
@@ -102,21 +105,21 @@ internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisS
 
     override fun getTypeScope(type: KtType): KtScope = withValidityAssertion {
         require(type is KtFe10Type)
-        return KtFe10ScopeMember(type.type.memberScope, analysisSession)
+        return KtFe10ScopeMember(type.type.memberScope, analysisContext)
     }
 
     override fun getScopeContextForPosition(originalFile: KtFile, positionInFakeFile: KtElement): KtScopeContext = withValidityAssertion {
         val elementToAnalyze = positionInFakeFile.containingNonLocalDeclaration() ?: originalFile
-        val bindingContext = analysisSession.analyze(elementToAnalyze)
+        val bindingContext = analysisContext.analyze(elementToAnalyze)
 
         val lexicalScope = positionInFakeFile.getResolutionScope(bindingContext)
         if (lexicalScope != null) {
-            val compositeScope = KtCompositeScope(listOf(KtFe10ScopeLexical(lexicalScope, analysisSession)), token)
+            val compositeScope = KtCompositeScope(listOf(KtFe10ScopeLexical(lexicalScope, analysisContext)), token)
             return KtScopeContext(compositeScope, collectImplicitReceivers(lexicalScope))
         }
 
-        val fileScope = analysisSession.resolveSession.fileScopeProvider.getFileResolutionScope(originalFile)
-        val compositeScope = KtCompositeScope(listOf(KtFe10ScopeLexical(fileScope, analysisSession)), token)
+        val fileScope = analysisContext.resolveSession.fileScopeProvider.getFileResolutionScope(originalFile)
+        val compositeScope = KtCompositeScope(listOf(KtFe10ScopeLexical(fileScope, analysisContext)), token)
         return KtScopeContext(compositeScope, collectImplicitReceivers(fileScope))
     }
 
@@ -135,9 +138,9 @@ internal class KtFe10ScopeProvider(override val analysisSession: KtFe10AnalysisS
         val result = mutableListOf<KtImplicitReceiver>()
 
         for (implicitReceiver in scope.getImplicitReceiversHierarchy()) {
-            val type = implicitReceiver.type.toKtType(analysisSession)
+            val type = implicitReceiver.type.toKtType(analysisContext)
             val ownerDescriptor = implicitReceiver.containingDeclaration
-            val owner = ownerDescriptor.toKtSymbol(analysisSession)
+            val owner = ownerDescriptor.toKtSymbol(analysisContext)
 
             if (owner == null) {
                 LOG.error("Unexpected implicit receiver owner: $ownerDescriptor (${ownerDescriptor.javaClass})")
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SmartCastProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SmartCastProvider.kt
index 6c42c09c22a..b52c0b0edc4 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SmartCastProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SmartCastProvider.kt
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtImplicitReceiverSmartCastK
 import org.jetbrains.kotlin.analysis.api.components.KtSmartCastInfo
 import org.jetbrains.kotlin.analysis.api.components.KtSmartCastProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
@@ -20,13 +21,15 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.ExplicitSmartCasts
 import org.jetbrains.kotlin.resolve.calls.smartcasts.MultipleSmartCasts
 import org.jetbrains.kotlin.types.TypeIntersector
 
-internal class KtFe10SmartCastProvider(override val analysisSession: KtFe10AnalysisSession) : KtSmartCastProvider() {
+internal class KtFe10SmartCastProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSmartCastProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun getSmartCastedInfo(expression: KtExpression): KtSmartCastInfo? {
         withValidityAssertion {
-            val bindingContext = analysisSession.analyze(expression)
+            val bindingContext = analysisContext.analyze(expression)
             val stableSmartCasts = bindingContext[BindingContext.SMARTCAST, expression]
             val unstableSmartCasts = bindingContext[BindingContext.UNSTABLE_SMARTCAST, expression]
 
@@ -46,18 +49,18 @@ internal class KtFe10SmartCastProvider(override val analysisSession: KtFe10Analy
 
     private fun ExplicitSmartCasts.getKtType(): KtType? {
         if (this is MultipleSmartCasts) {
-            return TypeIntersector.intersectTypes(map.values)?.toKtType(analysisSession)
+            return TypeIntersector.intersectTypes(map.values)?.toKtType(analysisContext)
         }
-        return defaultType?.toKtType(analysisSession)
+        return defaultType?.toKtType(analysisContext)
     }
 
     override fun getImplicitReceiverSmartCast(expression: KtExpression): Collection<KtImplicitReceiverSmartCast> {
         withValidityAssertion {
-            val bindingContext = analysisSession.analyze(expression)
+            val bindingContext = analysisContext.analyze(expression)
             val smartCasts = bindingContext[BindingContext.IMPLICIT_RECEIVER_SMARTCAST, expression] ?: return emptyList()
             return smartCasts.receiverTypes.map { (_, type) ->
                 val kind = KtImplicitReceiverSmartCastKind.DISPATCH // TODO provide precise kind
-                KtImplicitReceiverSmartCast(type.toKtType(analysisSession), kind, token)
+                KtImplicitReceiverSmartCast(type.toKtType(analysisContext), kind, token)
             }
         }
     }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SubtypingComponent.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SubtypingComponent.kt
index 5e260331d43..f85720dc6c4 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SubtypingComponent.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SubtypingComponent.kt
@@ -7,25 +7,28 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtSubtypingComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.withValidityAssertion
 
-internal class KtFe10SubtypingComponent(override val analysisSession: KtFe10AnalysisSession) : KtSubtypingComponent() {
+internal class KtFe10SubtypingComponent(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSubtypingComponent(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion {
         require(first is KtFe10Type)
         require(second is KtFe10Type)
-        return analysisSession.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.type, second.type)
+        return analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.type, second.type)
     }
 
     override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean = withValidityAssertion {
         require(subType is KtFe10Type)
         require(superType is KtFe10Type)
-        val typeChecker = analysisSession.resolveSession.kotlinTypeCheckerOfOwnerModule
+        val typeChecker = analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule
         return typeChecker.isSubtypeOf(subType.type, superType.type)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt
index 31319229a00..0d2714cfa32 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolContainingDeclarationProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolContainingDeclarationProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
@@ -20,7 +21,7 @@ import org.jetbrains.kotlin.cfg.getElementParentDeclaration
 
 internal class KtFe10SymbolContainingDeclarationProvider(
     override val analysisSession: KtFe10AnalysisSession
-) : KtSymbolContainingDeclarationProvider() {
+) : KtSymbolContainingDeclarationProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
@@ -32,7 +33,7 @@ internal class KtFe10SymbolContainingDeclarationProvider(
         return when (symbol) {
             is KtPackageSymbol -> null
             is KtBackingFieldSymbol -> symbol.owningProperty
-            is KtFe10DescSymbol<*> -> symbol.descriptor.containingDeclaration?.toKtSymbol(analysisSession) as? KtSymbolWithKind
+            is KtFe10DescSymbol<*> -> symbol.descriptor.containingDeclaration?.toKtSymbol(analysisContext) as? KtSymbolWithKind
             is KtFe10PsiSymbol<*, *> -> {
                 val parentDeclaration = symbol.psi.getElementParentDeclaration()
                 if (parentDeclaration != null) {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationOverridesProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationOverridesProvider.kt
index 28b8914ac0e..50a8f68d53f 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationOverridesProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationOverridesProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolDeclarationOverridesProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
@@ -21,18 +22,18 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isSubclassOf
 
 internal class KtFe10SymbolDeclarationOverridesProvider(
     override val analysisSession: KtFe10AnalysisSession
-) : KtSymbolDeclarationOverridesProvider() {
+) : KtSymbolDeclarationOverridesProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun <T : KtSymbol> getAllOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
         val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList()
-        return getOverriddenDescriptors(descriptor, true).mapNotNull { it.toKtCallableSymbol(analysisSession) }
+        return getOverriddenDescriptors(descriptor, true).mapNotNull { it.toKtCallableSymbol(analysisContext) }
     }
 
     override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {
         val descriptor = getSymbolDescriptor(callableSymbol) as? CallableMemberDescriptor ?: return emptyList()
-        return getOverriddenDescriptors(descriptor, false).mapNotNull { it.toKtCallableSymbol(analysisSession) }
+        return getOverriddenDescriptors(descriptor, false).mapNotNull { it.toKtCallableSymbol(analysisContext) }
     }
 
     private fun getOverriddenDescriptors(
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt
index 23a1b147a13..f313879b82e 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolDeclarationRendererProvider.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolDeclarationRendererProvider
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.render
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
@@ -19,14 +20,14 @@ import org.jetbrains.kotlin.analysis.api.types.KtType
 
 internal class KtFe10SymbolDeclarationRendererProvider(
     override val analysisSession: KtFe10AnalysisSession
-) : KtSymbolDeclarationRendererProvider() {
+) : KtSymbolDeclarationRendererProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun render(symbol: KtSymbol, options: KtDeclarationRendererOptions): String {
         val descriptor = getSymbolDescriptor(symbol)
         if (descriptor != null) {
-            return descriptor.render(analysisSession, options)
+            return descriptor.render(analysisContext, options)
         }
 
         // Rendering for unresolved symbols is not implemented
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolInfoProvider.kt
index 0c36d7bc214..1a22e8eb4a5 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolInfoProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolInfoProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtSymbolInfoProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
@@ -23,14 +24,16 @@ import org.jetbrains.kotlin.resolve.deprecation.DeprecationInfo
 import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 
-internal class KtFe10SymbolInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtSymbolInfoProvider() {
+internal class KtFe10SymbolInfoProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSymbolInfoProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override fun getDeprecation(symbol: KtSymbol): DeprecationInfo? {
         val descriptor = getSymbolDescriptor(symbol) ?: return null
         ForceResolveUtil.forceResolveAllContents(descriptor)
-        return analysisSession.deprecationResolver.getDeprecations(descriptor).firstOrNull()
+        return analysisContext.deprecationResolver.getDeprecations(descriptor).firstOrNull()
     }
 
     override fun getDeprecation(symbol: KtSymbol, annotationUseSiteTarget: AnnotationUseSiteTarget?): DeprecationInfo? {
@@ -41,14 +44,14 @@ internal class KtFe10SymbolInfoProvider(override val analysisSession: KtFe10Anal
         val getter = symbol.getter ?: return null
         val accessorDescriptor = getSymbolDescriptor(getter) as? PropertyAccessorDescriptor ?: return null
         ForceResolveUtil.forceResolveAllContents(accessorDescriptor.correspondingProperty)
-        return analysisSession.deprecationResolver.getDeprecations(accessorDescriptor).firstOrNull()
+        return analysisContext.deprecationResolver.getDeprecations(accessorDescriptor).firstOrNull()
     }
 
     override fun getSetterDeprecation(symbol: KtPropertySymbol): DeprecationInfo? {
         val getter = symbol.setter ?: return null
         val accessorDescriptor = getSymbolDescriptor(getter) as? PropertyAccessorDescriptor ?: return null
         ForceResolveUtil.forceResolveAllContents(accessorDescriptor.correspondingProperty)
-        return analysisSession.deprecationResolver.getDeprecations(accessorDescriptor).firstOrNull()
+        return analysisContext.deprecationResolver.getDeprecations(accessorDescriptor).firstOrNull()
     }
 
     override fun getJavaGetterName(symbol: KtPropertySymbol): Name {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolProvider.kt
index 429adeb0149..ca545e4bf13 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SymbolProvider.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10FileSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtClassSymbol
@@ -21,70 +22,72 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 
-internal class KtFe10SymbolProvider(override val analysisSession: KtFe10AnalysisSession) : KtSymbolProvider() {
+internal class KtFe10SymbolProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtSymbolProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
     override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol
-        get() = KtFe10PackageSymbol(FqName.ROOT, analysisSession)
+        get() = KtFe10PackageSymbol(FqName.ROOT, analysisContext)
 
     override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion {
-        return KtFe10FileSymbol(psi, analysisSession)
+        return KtFe10FileSymbol(psi, analysisContext)
     }
 
     override fun getParameterSymbol(psi: KtParameter): KtValueParameterSymbol = withValidityAssertion {
-        return KtFe10PsiValueParameterSymbol(psi, analysisSession)
+        return KtFe10PsiValueParameterSymbol(psi, analysisContext)
     }
 
     override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
         return if (psi.hasBody() && (psi.funKeyword == null || psi.nameIdentifier == null)) {
             getAnonymousFunctionSymbol(psi)
         } else {
-            KtFe10PsiFunctionSymbol(psi, analysisSession)
+            KtFe10PsiFunctionSymbol(psi, analysisContext)
         }
     }
 
     override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
-        return KtFe10PsiConstructorSymbol(psi, analysisSession)
+        return KtFe10PsiConstructorSymbol(psi, analysisContext)
     }
 
     override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
-        return KtFe10PsiTypeParameterSymbol(psi, analysisSession)
+        return KtFe10PsiTypeParameterSymbol(psi, analysisContext)
     }
 
     override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
-        return KtFe10PsiTypeAliasSymbol(psi, analysisSession)
+        return KtFe10PsiTypeAliasSymbol(psi, analysisContext)
     }
 
     override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
-        return KtFe10PsiEnumEntrySymbol(psi, analysisSession)
+        return KtFe10PsiEnumEntrySymbol(psi, analysisContext)
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
-        return KtFe10PsiAnonymousFunctionSymbol(psi, analysisSession)
+        return KtFe10PsiAnonymousFunctionSymbol(psi, analysisContext)
     }
 
     override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
-        return KtFe10PsiLiteralAnonymousFunctionSymbol(psi, analysisSession)
+        return KtFe10PsiLiteralAnonymousFunctionSymbol(psi, analysisContext)
     }
 
     override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
         return if (psi.isLocal) {
-            KtFe10PsiLocalVariableSymbol(psi, analysisSession)
+            KtFe10PsiLocalVariableSymbol(psi, analysisContext)
         } else {
-            KtFe10PsiKotlinPropertySymbol(psi, analysisSession)
+            KtFe10PsiKotlinPropertySymbol(psi, analysisContext)
         }
     }
 
     override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
-        return KtFe10PsiAnonymousObjectSymbol(psi.objectDeclaration, analysisSession)
+        return KtFe10PsiAnonymousObjectSymbol(psi.objectDeclaration, analysisContext)
     }
 
     override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
         return if (psi is KtObjectDeclaration && psi.isObjectLiteral()) {
-            KtFe10PsiAnonymousObjectSymbol(psi, analysisSession)
+            KtFe10PsiAnonymousObjectSymbol(psi, analysisContext)
         } else {
-            KtFe10PsiNamedClassOrObjectSymbol(psi, analysisSession)
+            KtFe10PsiNamedClassOrObjectSymbol(psi, analysisContext)
         }
     }
 
@@ -93,31 +96,31 @@ internal class KtFe10SymbolProvider(override val analysisSession: KtFe10Analysis
             return null
         }
 
-        return KtFe10PsiNamedClassOrObjectSymbol(psi, analysisSession)
+        return KtFe10PsiNamedClassOrObjectSymbol(psi, analysisContext)
     }
 
     override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
         return if (psi.isGetter) {
-            KtFe10PsiPropertyGetterSymbol(psi, analysisSession)
+            KtFe10PsiPropertyGetterSymbol(psi, analysisContext)
         } else {
-            KtFe10PsiPropertySetterSymbol(psi, analysisSession)
+            KtFe10PsiPropertySetterSymbol(psi, analysisContext)
         }
     }
 
     override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
-        return KtFe10PsiClassInitializerSymbol(psi, analysisSession)
+        return KtFe10PsiClassInitializerSymbol(psi, analysisContext)
     }
 
     override fun getClassOrObjectSymbolByClassId(classId: ClassId): KtClassOrObjectSymbol? = withValidityAssertion {
-        val descriptor = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
-        return descriptor.toKtClassSymbol(analysisSession)
+        val descriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
+        return descriptor.toKtClassSymbol(analysisContext)
     }
 
     override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): Sequence<KtSymbol> = withValidityAssertion {
-        val packageViewDescriptor = analysisSession.resolveSession.moduleDescriptor.getPackage(packageFqName)
+        val packageViewDescriptor = analysisContext.resolveSession.moduleDescriptor.getPackage(packageFqName)
         return packageViewDescriptor.memberScope.getContributedDescriptors(DescriptorKindFilter.ALL, nameFilter = { it == name })
             .asSequence()
             .filter { it.name == name }
-            .mapNotNull { it.toKtSymbol(analysisSession) as? KtCallableSymbol }
+            .mapNotNull { it.toKtSymbol(analysisContext) as? KtCallableSymbol }
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeCreator.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeCreator.kt
index f721ae2a546..710339561f3 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeCreator.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeCreator.kt
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
 import org.jetbrains.kotlin.analysis.api.components.KtClassTypeBuilder
 import org.jetbrains.kotlin.analysis.api.components.KtTypeCreator
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.types.KtFe10ClassErrorType
 import org.jetbrains.kotlin.analysis.api.descriptors.types.KtFe10UsualClassType
@@ -22,7 +23,9 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.types.*
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
-internal class KtFe10TypeCreator(override val analysisSession: KtFe10AnalysisSession) : KtTypeCreator() {
+internal class KtFe10TypeCreator(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeCreator(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
@@ -30,7 +33,7 @@ internal class KtFe10TypeCreator(override val analysisSession: KtFe10AnalysisSes
         val descriptor: ClassDescriptor? = when (builder) {
             is KtClassTypeBuilder.ByClassId -> {
                 val fqName = builder.classId.asSingleFqName()
-                analysisSession.resolveSession
+                analysisContext.resolveSession
                     .getTopLevelClassifierDescriptors(fqName, NoLookupLocation.FROM_IDE)
                     .firstIsInstanceOrNull()
             }
@@ -41,7 +44,7 @@ internal class KtFe10TypeCreator(override val analysisSession: KtFe10AnalysisSes
 
         if (descriptor == null) {
             val kotlinType = ErrorUtils.createErrorType("Cannot build class type, descriptor not found for builder $builder")
-            return KtFe10ClassErrorType(kotlinType as ErrorType, analysisSession)
+            return KtFe10ClassErrorType(kotlinType as ErrorType, analysisContext)
         }
 
         val typeParameters = descriptor.typeConstructor.parameters
@@ -59,6 +62,6 @@ internal class KtFe10TypeCreator(override val analysisSession: KtFe10AnalysisSes
         }
 
         val typeWithNullability = TypeUtils.makeNullableAsSpecified(type, builder.nullability == KtTypeNullability.NULLABLE)
-        return KtFe10UsualClassType(typeWithNullability as SimpleType, descriptor, analysisSession)
+        return KtFe10UsualClassType(typeWithNullability as SimpleType, descriptor, analysisContext)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt
index 61e4359b80d..3a7956967ca 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeInfoProvider.kt
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtTypeInfoProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
@@ -16,7 +17,9 @@ import org.jetbrains.kotlin.builtins.getFunctionalClassKind
 import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils
 import org.jetbrains.kotlin.types.TypeUtils
 
-internal class KtFe10TypeInfoProvider(override val analysisSession: KtFe10AnalysisSession) : KtTypeInfoProvider() {
+internal class KtFe10TypeInfoProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeInfoProvider(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt
index 4336a9bb803..418c946d6c7 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10TypeProvider.kt
@@ -7,8 +7,10 @@ package org.jetbrains.kotlin.analysis.api.descriptors.components
 
 import org.jetbrains.kotlin.analysis.api.components.KtBuiltinTypes
 import org.jetbrains.kotlin.analysis.api.components.KtTypeProvider
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.isInterfaceLike
@@ -40,53 +42,55 @@ import org.jetbrains.kotlin.types.typeUtil.isNothing
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.util.containingNonLocalDeclaration
 
-internal class KtFe10TypeProvider(override val analysisSession: KtFe10AnalysisSession) : KtTypeProvider() {
+internal class KtFe10TypeProvider(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtTypeProvider(), Fe10KtAnalysisSessionComponent {
     @Suppress("SpellCheckingInspection")
     private val typeApproximator by lazy {
         TypeApproximator(
-            analysisSession.resolveSession.moduleDescriptor.builtIns,
-            analysisSession.resolveSession.languageVersionSettings
+            analysisContext.resolveSession.moduleDescriptor.builtIns,
+            analysisContext.resolveSession.languageVersionSettings
         )
     }
 
     override val token: ValidityToken
         get() = analysisSession.token
 
-    override val builtinTypes: KtBuiltinTypes by cached { KtFe10BuiltinTypes(analysisSession) }
+    override val builtinTypes: KtBuiltinTypes by cached { KtFe10BuiltinTypes(analysisContext) }
 
     override fun approximateToSuperPublicDenotableType(type: KtType): KtType? = withValidityAssertion {
         require(type is KtFe10Type)
-        return typeApproximator.approximateToSuperType(type.type, PublicApproximatorConfiguration)?.toKtType(analysisSession)
+        return typeApproximator.approximateToSuperType(type.type, PublicApproximatorConfiguration)?.toKtType(analysisContext)
     }
 
     override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType = withValidityAssertion {
         val kotlinType = (getSymbolDescriptor(symbol) as? ClassDescriptor)?.defaultType
             ?: ErrorUtils.createErrorType("Cannot get class type for unresolved class ${symbol.nameOrAnonymous}")
 
-        return kotlinType.toKtType(analysisSession)
+        return kotlinType.toKtType(analysisContext)
     }
 
     override fun commonSuperType(types: Collection<KtType>): KtType = withValidityAssertion {
         val kotlinTypes = types.map { (it as KtFe10Type).type }
-        return CommonSupertypes.commonSupertype(kotlinTypes).toKtType(analysisSession)
+        return CommonSupertypes.commonSupertype(kotlinTypes).toKtType(analysisContext)
     }
 
     override fun getKtType(ktTypeReference: KtTypeReference): KtType = withValidityAssertion {
-        val bindingContext = analysisSession.analyze(ktTypeReference, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(ktTypeReference, AnalysisMode.PARTIAL)
         val kotlinType = bindingContext[BindingContext.TYPE, ktTypeReference]
             ?: ErrorUtils.createErrorType("Cannot resolve type reference ${ktTypeReference.text}")
-        return kotlinType.toKtType(analysisSession)
+        return kotlinType.toKtType(analysisContext)
     }
 
     override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? = withValidityAssertion {
-        val bindingContext = analysisSession.analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
         val lhs = bindingContext[BindingContext.DOUBLE_COLON_LHS, expression] ?: return null
-        return lhs.type.toKtType(analysisSession)
+        return lhs.type.toKtType(analysisContext)
     }
 
     override fun withNullability(type: KtType, newNullability: KtTypeNullability): KtType = withValidityAssertion {
         require(type is KtFe10Type)
-        return type.type.makeNullableAsSpecified(newNullability == KtTypeNullability.NULLABLE).toKtType(analysisSession)
+        return type.type.makeNullableAsSpecified(newNullability == KtTypeNullability.NULLABLE).toKtType(analysisContext)
     }
 
     override fun haveCommonSubtype(a: KtType, b: KtType): Boolean {
@@ -95,20 +99,20 @@ internal class KtFe10TypeProvider(override val analysisSession: KtFe10AnalysisSe
 
     override fun getImplicitReceiverTypesAtPosition(position: KtElement): List<KtType> {
         val elementToAnalyze = position.containingNonLocalDeclaration() ?: position
-        val bindingContext = analysisSession.analyze(elementToAnalyze)
+        val bindingContext = analysisContext.analyze(elementToAnalyze)
 
         val lexicalScope = position.getResolutionScope(bindingContext) ?: return emptyList()
-        return lexicalScope.getImplicitReceiversHierarchy().map { it.type.toKtType(analysisSession) }
+        return lexicalScope.getImplicitReceiversHierarchy().map { it.type.toKtType(analysisContext) }
     }
 
     override fun getDirectSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
         require(type is KtFe10Type)
-        return TypeUtils.getImmediateSupertypes(type.type).map { it.toKtType(analysisSession) }
+        return TypeUtils.getImmediateSupertypes(type.type).map { it.toKtType(analysisContext) }
     }
 
     override fun getAllSuperTypes(type: KtType, shouldApproximate: Boolean): List<KtType> {
         require(type is KtFe10Type)
-        return TypeUtils.getAllSupertypes(type.type).map { it.toKtType(analysisSession) }
+        return TypeUtils.getAllSupertypes(type.type).map { it.toKtType(analysisContext) }
     }
 
     private fun areTypesCompatible(a: KotlinType, b: KotlinType): Boolean {
@@ -227,7 +231,7 @@ internal class KtFe10TypeProvider(override val analysisSession: KtFe10AnalysisSe
                 for ((typeParameterDescriptor, boundTypeArgument) in mapping) {
                     val boundsForParameter = typeArgumentMapping.computeIfAbsent(typeParameterDescriptor) {
                         var isCompatible = true
-                        val languageVersionSettings = analysisSession.resolveSession.languageVersionSettings
+                        val languageVersionSettings = analysisContext.resolveSession.languageVersionSettings
                         if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitComparisonOfIncompatibleEnums)) {
                             isCompatible = isCompatible && typeParameterOwner.classId != StandardClassIds.Enum
                         }
@@ -397,55 +401,55 @@ internal class KtFe10TypeProvider(override val analysisSession: KtFe10AnalysisSe
     }
 }
 
-private class KtFe10BuiltinTypes(private val analysisSession: KtFe10AnalysisSession) : KtBuiltinTypes() {
+private class KtFe10BuiltinTypes(private val analysisContext: Fe10AnalysisContext) : KtBuiltinTypes() {
     override val token: ValidityToken
-        get() = analysisSession.token
+        get() = analysisContext.token
 
-    private val builtIns = analysisSession.resolveSession.moduleDescriptor.builtIns
+    private val builtIns = analysisContext.resolveSession.moduleDescriptor.builtIns
 
     override val INT: KtType
-        get() = withValidityAssertion { builtIns.intType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.intType.toKtType(analysisContext) }
 
     override val LONG: KtType
-        get() = withValidityAssertion { builtIns.longType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.longType.toKtType(analysisContext) }
 
     override val SHORT: KtType
-        get() = withValidityAssertion { builtIns.shortType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.shortType.toKtType(analysisContext) }
 
     override val BYTE: KtType
-        get() = withValidityAssertion { builtIns.byteType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.byteType.toKtType(analysisContext) }
 
     override val FLOAT: KtType
-        get() = withValidityAssertion { builtIns.floatType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.floatType.toKtType(analysisContext) }
 
     override val DOUBLE: KtType
-        get() = withValidityAssertion { builtIns.doubleType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.doubleType.toKtType(analysisContext) }
 
     override val BOOLEAN: KtType
-        get() = withValidityAssertion { builtIns.booleanType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.booleanType.toKtType(analysisContext) }
 
     override val CHAR: KtType
-        get() = withValidityAssertion { builtIns.charType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.charType.toKtType(analysisContext) }
 
     override val STRING: KtType
-        get() = withValidityAssertion { builtIns.stringType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.stringType.toKtType(analysisContext) }
 
     override val UNIT: KtType
-        get() = withValidityAssertion { builtIns.unitType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.unitType.toKtType(analysisContext) }
 
     override val NOTHING: KtType
-        get() = withValidityAssertion { builtIns.nothingType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.nothingType.toKtType(analysisContext) }
 
     override val ANY: KtType
-        get() = withValidityAssertion { builtIns.anyType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.anyType.toKtType(analysisContext) }
 
     override val THROWABLE: KtType
-        get() = withValidityAssertion { builtIns.throwable.defaultType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.throwable.defaultType.toKtType(analysisContext) }
 
     override val NULLABLE_ANY: KtType
-        get() = withValidityAssertion { builtIns.nullableAnyType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.nullableAnyType.toKtType(analysisContext) }
 
     override val NULLABLE_NOTHING: KtType
-        get() = withValidityAssertion { builtIns.nullableNothingType.toKtType(analysisSession) }
+        get() = withValidityAssertion { builtIns.nullableNothingType.toKtType(analysisContext) }
 
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt
index 7230d7abed6..4ee7145c334 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10VisibilityChecker.kt
@@ -9,6 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.components.KtVisibilityChecker
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.getResolutionScope
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
@@ -25,7 +26,9 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.utils.getImplicitReceiversHierarchy
 
-internal class KtFe10VisibilityChecker(override val analysisSession: KtFe10AnalysisSession) : KtVisibilityChecker() {
+internal class KtFe10VisibilityChecker(
+    override val analysisSession: KtFe10AnalysisSession
+) : KtVisibilityChecker(), Fe10KtAnalysisSessionComponent {
     override val token: ValidityToken
         get() = analysisSession.token
 
@@ -42,16 +45,16 @@ internal class KtFe10VisibilityChecker(override val analysisSession: KtFe10Analy
         val targetDescriptor = getSymbolDescriptor(candidateSymbol) as? DeclarationDescriptorWithVisibility ?: return false
 
         val useSiteDeclaration = findContainingNonLocalDeclaration(position) ?: return false
-        val bindingContextForUseSite = analysisSession.analyze(useSiteDeclaration)
+        val bindingContextForUseSite = analysisContext.analyze(useSiteDeclaration)
         val useSiteDescriptor = bindingContextForUseSite[BindingContext.DECLARATION_TO_DESCRIPTOR, useSiteDeclaration] ?: return false
 
         if (receiverExpression != null && !targetDescriptor.isExtension) {
-            val bindingContext = analysisSession.analyze(receiverExpression, AnalysisMode.PARTIAL)
+            val bindingContext = analysisContext.analyze(receiverExpression, AnalysisMode.PARTIAL)
             val receiverType = bindingContext.getType(receiverExpression) ?: return false
             val explicitReceiver = ExpressionReceiver.create(receiverExpression, receiverType, bindingContext)
             return DescriptorVisibilities.isVisible(explicitReceiver, targetDescriptor, useSiteDescriptor)
         } else {
-            val bindingContext = analysisSession.analyze(useSiteDeclaration, AnalysisMode.FULL)
+            val bindingContext = analysisContext.analyze(useSiteDeclaration, AnalysisMode.FULL)
 
             val lexicalScope = position.getResolutionScope(bindingContext)
             if (lexicalScope != null) {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/base/Fe10KtAnalysisSessionComponent.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/base/Fe10KtAnalysisSessionComponent.kt
new file mode 100644
index 00000000000..b838b5f4c2e
--- /dev/null
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/base/Fe10KtAnalysisSessionComponent.kt
@@ -0,0 +1,16 @@
+/*
+ * 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.descriptors.components.base
+
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+
+interface Fe10KtAnalysisSessionComponent {
+    val analysisSession: KtFe10AnalysisSession
+
+    val analysisContext: Fe10AnalysisContext
+        get() = analysisSession.analysisContext
+}
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt
index 4e3bfaf3d94..90afe217550 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ArrayAccessReference.kt
@@ -21,9 +21,9 @@ abstract class KtFe10ArrayAccessReference(expression: KtArrayAccessExpression) :
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         require(this is KtFe10AnalysisSession)
 
-        val bindingContext = analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
         val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor
-        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+        return listOfNotNull(descriptor?.toKtCallableSymbol(analysisContext))
     }
 }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt
index ea15af2586b..38cbfce95d5 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10CollectionLiteralReference.kt
@@ -22,9 +22,9 @@ abstract class KtFe10CollectionLiteralReference(
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         require(this is KtFe10AnalysisSession)
 
-        val bindingContext = analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
         val descriptor = bindingContext[BindingContext.COLLECTION_LITERAL_CALL, expression]?.resultingDescriptor
-        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+        return listOfNotNull(descriptor?.toKtCallableSymbol(analysisContext))
     }
 }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt
index 3dae977f9f3..74f39767aed 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ConstructorDelegationReference.kt
@@ -22,9 +22,9 @@ abstract class KtFe10ConstructorDelegationReference(
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         require(this is KtFe10AnalysisSession)
 
-        val bindingContext = analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
         val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor
-        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+        return listOfNotNull(descriptor?.toKtCallableSymbol(analysisContext))
     }
 }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt
index 38dea7e53bc..5de65a8be6b 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10DestructuringDeclarationEntry.kt
@@ -22,9 +22,9 @@ abstract class KtFe10DestructuringDeclarationEntry(
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         check(this is KtFe10AnalysisSession)
 
-        val bindingContext = analyze(element, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(element, AnalysisMode.PARTIAL)
         val descriptor = bindingContext[BindingContext.COMPONENT_RESOLVED_CALL, element]?.resultingDescriptor
-        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+        return listOfNotNull(descriptor?.toKtCallableSymbol(analysisContext))
     }
 }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt
index a98a141799d..653bd34761f 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10ForLoopInReference.kt
@@ -20,13 +20,13 @@ abstract class KtFe10ForLoopInReference(expression: KtForExpression) : KtForLoop
         check(this is KtFe10AnalysisSession)
 
         val loopRange = element.loopRange ?: return emptyList()
-        val bindingContext = analyze(loopRange)
+        val bindingContext = analysisContext.analyze(loopRange)
 
         return listOf(
             BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL,
             BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL,
             BindingContext.LOOP_RANGE_NEXT_RESOLVED_CALL
-        ).mapNotNull { slice -> bindingContext[slice, loopRange]?.resultingDescriptor?.toKtCallableSymbol(this) }
+        ).mapNotNull { slice -> bindingContext[slice, loopRange]?.resultingDescriptor?.toKtCallableSymbol(analysisContext) }
     }
 }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt
index 721e1fe49f9..682b9c7869b 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10InvokeFunctionReference.kt
@@ -21,9 +21,9 @@ abstract class KtFe10InvokeFunctionReference(expression: KtCallExpression) : KtI
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         require(this is KtFe10AnalysisSession)
 
-        val bindingContext = analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
         val descriptor = expression.getResolvedCall(bindingContext)?.resultingDescriptor
-        return listOfNotNull(descriptor?.toKtCallableSymbol(this))
+        return listOfNotNull(descriptor?.toKtCallableSymbol(analysisContext))
     }
 }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt
index 1d7b0391f14..423b7d75b88 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10PropertyDelegationMethodsReference.kt
@@ -28,14 +28,14 @@ abstract class KtFe10PropertyDelegationMethodsReference(
             return emptyList()
         }
 
-        val bindingContext = analyze(property)
+        val bindingContext = analysisContext.analyze(property)
         val propertyDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, property]
 
         if (propertyDescriptor is PropertyDescriptor) {
             return listOfNotNull(propertyDescriptor.getter, propertyDescriptor.setter)
                 .mapNotNull { accessor ->
                     val descriptor = bindingContext[BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, accessor]?.resultingDescriptor
-                    descriptor?.toKtCallableSymbol(this)
+                    descriptor?.toKtCallableSymbol(analysisContext)
                 }
         }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt
index c161700da3d..7cc9cca4d3e 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/references/KtFe10SimpleNameReference.kt
@@ -24,12 +24,12 @@ abstract class KtFe10SimpleNameReference(expression: KtSimpleNameExpression) : K
     override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
         require(this is KtFe10AnalysisSession)
 
-        val bindingContext = analyze(expression, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
 
         val descriptor = bindingContext[BindingContext.REFERENCE_TARGET, expression]
             ?: expression.getResolvedCall(bindingContext)?.resultingDescriptor
 
-        return listOfNotNull(descriptor?.toKtSymbol(this))
+        return listOfNotNull(descriptor?.toKtSymbol(analysisContext))
     }
 }
 
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 49548ff2891..9280181757d 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
@@ -33,8 +33,8 @@ object KtFe10PolyVariantResolver : ResolveCache.PolyVariantResolver<KtReference>
         return runInPossiblyEdtThread {
             val expression = reference.expression
             analyse(reference.expression) {
-                val session = this as KtFe10AnalysisSession
-                val bindingContext = session.analyze(expression, AnalysisMode.PARTIAL)
+                val analysisSession = this as KtFe10AnalysisSession
+                val bindingContext = analysisSession.analysisContext.analyze(expression, AnalysisMode.PARTIAL)
                 val descriptor = when (expression) {
                     is KtReferenceExpression -> bindingContext[BindingContext.REFERENCE_TARGET, expression]
                     else -> expression.getResolvedCall(bindingContext)?.resultingDescriptor
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt
index c7b0617cb50..5c262df0432 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10PackageScope.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.scopes
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
 import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
@@ -16,13 +16,13 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope
 internal class KtFe10PackageScope(
     scope: MemberScope,
     private val owner: KtPackageSymbol,
-    analysisSession: KtFe10AnalysisSession
-) : KtFe10ScopeMember(scope, analysisSession) {
+    analysisContext: Fe10AnalysisContext
+) : KtFe10ScopeMember(scope, analysisContext) {
     override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {
-        val packageFragmentProvider = analysisSession.resolveSession.packageFragmentProvider
+        val packageFragmentProvider = analysisContext.resolveSession.packageFragmentProvider
         return packageFragmentProvider.getSubPackagesOf(owner.fqName, nameFilter)
             .asSequence()
-            .map { KtFe10PackageSymbol(it, analysisSession) }
+            .map { KtFe10PackageSymbol(it, analysisContext) }
     }
 
     override fun getConstructors(): Sequence<KtConstructorSymbol> = withValidityAssertion {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt
index f3935e3cf91..3db93be7200 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/scopes/KtFe10ScopeResolution.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.scopes
 
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstructorSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
@@ -25,7 +26,7 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.scopes.ResolutionScope
 
 internal abstract class KtFe10ScopeResolution : KtScope, ValidityTokenOwner {
-    abstract val analysisSession: KtFe10AnalysisSession
+    abstract val analysisContext: Fe10AnalysisContext
     abstract val scope: ResolutionScope
 
     override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
@@ -33,7 +34,7 @@ internal abstract class KtFe10ScopeResolution : KtScope, ValidityTokenOwner {
             .getContributedDescriptors(kindFilter = DescriptorKindFilter.ALL, nameFilter)
             .asSequence()
             .filter { nameFilter(it.name) }
-            .mapNotNull { it.toKtSymbol(analysisSession) as? KtCallableSymbol }
+            .mapNotNull { it.toKtSymbol(analysisContext) as? KtCallableSymbol }
     }
 
     override fun getClassifierSymbols(nameFilter: KtScopeNameFilter): Sequence<KtClassifierSymbol> = withValidityAssertion {
@@ -41,7 +42,7 @@ internal abstract class KtFe10ScopeResolution : KtScope, ValidityTokenOwner {
             .getContributedDescriptors(kindFilter = DescriptorKindFilter.CLASSIFIERS, nameFilter)
             .asSequence()
             .filter { nameFilter(it.name) }
-            .mapNotNull { it.toKtSymbol(analysisSession) as? KtClassifierSymbol }
+            .mapNotNull { it.toKtSymbol(analysisContext) as? KtClassifierSymbol }
     }
 
     override fun getConstructors(): Sequence<KtConstructorSymbol> = withValidityAssertion {
@@ -49,7 +50,7 @@ internal abstract class KtFe10ScopeResolution : KtScope, ValidityTokenOwner {
             .getContributedDescriptors(kindFilter = DescriptorKindFilter.FUNCTIONS)
             .asSequence()
             .filterIsInstance<ConstructorDescriptor>()
-            .map { it.toKtConstructorSymbol(analysisSession) }
+            .map { it.toKtConstructorSymbol(analysisContext) }
     }
 
     override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {
@@ -57,12 +58,12 @@ internal abstract class KtFe10ScopeResolution : KtScope, ValidityTokenOwner {
     }
 
     override val token: ValidityToken
-        get() = analysisSession.token
+        get() = analysisContext.token
 }
 
 internal class KtFe10ScopeLexical(
     override val scope: LexicalScope,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFe10ScopeResolution(), ValidityTokenOwner {
     override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
         return emptySet()
@@ -75,9 +76,8 @@ internal class KtFe10ScopeLexical(
 
 internal open class KtFe10ScopeMember(
     override val scope: MemberScope,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFe10ScopeResolution() {
-
     override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
         return scope.getFunctionNames() + scope.getVariableNames()
     }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt
index 8216340d70e..484ea828498 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10FileSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10AnnotatedSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
@@ -19,13 +19,13 @@ import org.jetbrains.kotlin.psi.KtFile
 
 internal class KtFe10FileSymbol(
     private val file: KtFile,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFileSymbol(), KtSymbolWithDeclarations, KtFe10AnnotatedSymbol {
     override val psi: KtFile
         get() = withValidityAssertion { file }
 
     override val annotationsObject: Annotations
-        get() = analysisSession.resolveSession.getFileAnnotations(file)
+        get() = analysisContext.resolveSession.getFileAnnotations(file)
 
     override val origin: KtSymbolOrigin
         get() = withValidityAssertion { if (file.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt
index 674e4218665..adef684a5e9 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/KtFe10PackageSymbol.kt
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.symbols
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiUtilCore
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10PackageSymbolPointer
@@ -20,13 +21,13 @@ import org.jetbrains.kotlin.name.FqName
 
 internal class KtFe10PackageSymbol(
     private val packageName: FqName,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtPackageSymbol(), KtFe10Symbol {
     override val fqName: FqName
         get() = withValidityAssertion { packageName }
 
     override val psi: PsiElement? by cached {
-        val project = analysisSession.resolveSession.project
+        val project = analysisContext.resolveSession.project
         JavaPsiFacade.getInstance(project).findPackage(fqName.asString())
     }
 
@@ -38,7 +39,7 @@ internal class KtFe10PackageSymbol(
         get() = withValidityAssertion {
             val virtualFile = PsiUtilCore.getVirtualFile(psi)
             return if (virtualFile != null) {
-                analysisSession.getOrigin(virtualFile)
+                analysisContext.getOrigin(virtualFile)
             } else {
                 KtSymbolOrigin.LIBRARY
             }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt
index ae53db26cb4..de629c40027 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/base/KtFe10Symbol.kt
@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.base
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 
 interface KtFe10Symbol : KtSymbol {
-    val analysisSession: KtFe10AnalysisSession
+    val analysisContext: Fe10AnalysisContext
 
     override val token: ValidityToken
-        get() = analysisSession.token
+        get() = analysisContext.token
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt
index b795db4139f..9c6cac45265 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousFunctionSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktHasStableParameterNames
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -22,22 +22,22 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 
 internal class KtFe10DescAnonymousFunctionSymbol(
     override val descriptor: FunctionDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtAnonymousFunctionSymbol(), KtFe10DescMemberSymbol<FunctionDescriptor> {
     override val isExtension: Boolean
         get() = withValidityAssertion { descriptor.isExtension }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousFunctionSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt
index 665e97f0be2..2fa7cdbd5a0 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescAnonymousObjectSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -18,10 +18,10 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 
 internal class KtFe10DescAnonymousObjectSymbol(
     override val descriptor: ClassDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtAnonymousObjectSymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
     override val superTypes: List<KtTypeAndAnnotations>
-        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtTypeAndAnnotations(analysisSession) } }
+        get() = withValidityAssertion { descriptor.typeConstructor.supertypes.map { it.toKtTypeAndAnnotations(analysisContext) } }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt
index c543d3feee2..bd7f95d7af5 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescConstructorSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescFunctionLikeSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.ClassId
 
 internal class KtFe10DescConstructorSymbol(
     override val descriptor: ConstructorDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtConstructorSymbol(), KtFe10DescMemberSymbol<ConstructorDescriptor> {
     override val isPrimary: Boolean
         get() = withValidityAssertion { descriptor.isPrimary }
@@ -32,22 +32,22 @@ internal class KtFe10DescConstructorSymbol(
         get() = withValidityAssertion { descriptor.constructedClass.classId }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisContext) }
 
     override val dispatchType: KtType?
         get() = withValidityAssertion {
             val containingClass = descriptor.constructedClass.containingDeclaration as? ClassDescriptor ?: return null
-            return containingClass.defaultType.toKtType(analysisSession)
+            return containingClass.defaultType.toKtType(analysisContext)
         }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisContext) } }
 
     override fun createPointer(): KtSymbolPointer<KtConstructorSymbol> = withValidityAssertion {
         val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
@@ -57,7 +57,7 @@ internal class KtFe10DescConstructorSymbol(
 
         val callableId = descriptor.callableId
         if (callableId != null && !callableId.isLocal) {
-            val signature = descriptor.getSymbolPointerSignature(analysisSession)
+            val signature = descriptor.getSymbolPointerSignature(analysisContext)
             return KtFe10DescFunctionLikeSymbolPointer(callableId, signature)
         }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt
index cc0cb84fb32..91db3ca90eb 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescEnumEntrySymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFe10DescEnumEntrySymbol(
     override val descriptor: ClassDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtEnumEntrySymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
     private val enumDescriptor: ClassDescriptor
         get() = descriptor.containingDeclaration as ClassDescriptor
@@ -42,7 +42,7 @@ internal class KtFe10DescEnumEntrySymbol(
         }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { enumDescriptor.defaultType.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { enumDescriptor.defaultType.toKtTypeAndAnnotations(analysisContext) }
 
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt
index 40fb37575a3..271b038f970 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescFunctionSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescFunctionLikeSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 
 internal class KtFe10DescFunctionSymbol(
     override val descriptor: FunctionDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFunctionSymbol(), KtFe10DescMemberSymbol<FunctionDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -58,7 +58,7 @@ internal class KtFe10DescFunctionSymbol(
         get() = withValidityAssertion { descriptor is JavaCallableMemberDescriptor && DescriptorUtils.isStaticDeclaration(descriptor) }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
@@ -67,19 +67,19 @@ internal class KtFe10DescFunctionSymbol(
         get() = withValidityAssertion { descriptor.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val isExtension: Boolean
         get() = withValidityAssertion { descriptor.isExtension }
 
     override val dispatchType: KtType?
-        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.typeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisContext) } }
 
     override fun createPointer(): KtSymbolPointer<KtFunctionSymbol> = withValidityAssertion {
         val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
@@ -89,7 +89,7 @@ internal class KtFe10DescFunctionSymbol(
 
         val callableId = descriptor.callableId
         if (callableId != null && !callableId.isLocal) {
-            val signature = descriptor.getSymbolPointerSignature(analysisSession)
+            val signature = descriptor.getSymbolPointerSignature(analysisContext)
             return KtFe10DescFunctionLikeSymbolPointer(callableId, signature)
         }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt
index 549ed70bf2c..326442aba05 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescJavaFieldSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescMemberSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.callableId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 internal class KtFe10DescJavaFieldSymbol(
     override val descriptor: JavaPropertyDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtJavaFieldSymbol(), KtFe10DescMemberSymbol<JavaPropertyDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -37,7 +37,7 @@ internal class KtFe10DescJavaFieldSymbol(
         get() = withValidityAssertion { descriptor.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnType.toKtTypeAndAnnotations(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtJavaFieldSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt
index a9289906cc3..bb780e5310b 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescKotlinPropertySymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 
 internal class KtFe10DescKotlinPropertySymbol(
     override val descriptor: PropertyDescriptorImpl,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtKotlinPropertySymbol(), KtFe10DescMemberSymbol<PropertyDescriptorImpl> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -72,27 +72,27 @@ internal class KtFe10DescKotlinPropertySymbol(
     override val getter: KtPropertyGetterSymbol?
         get() = withValidityAssertion {
             val getter = descriptor.getter ?: return null
-            return KtFe10DescPropertyGetterSymbol(getter, analysisSession)
+            return KtFe10DescPropertyGetterSymbol(getter, analysisContext)
         }
 
     override val setter: KtPropertySetterSymbol?
         get() = withValidityAssertion {
             val setter = descriptor.setter ?: return null
-            return KtFe10DescPropertySetterSymbol(setter, analysisSession)
+            return KtFe10DescPropertySetterSymbol(setter, analysisContext)
         }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val dispatchType: KtType?
-        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val hasBackingField: Boolean
         get() = withValidityAssertion {
-            val bindingContext = analysisSession.resolveSession.bindingContext
+            val bindingContext = analysisContext.resolveSession.bindingContext
             return bindingContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] == true
         }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt
index 349be16ec2b..c7d3edc9f70 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescLocalVariableSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFe10DescLocalVariableSymbol(
     override val descriptor: LocalVariableDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtLocalVariableSymbol(), KtFe10DescSymbol<LocalVariableDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -29,7 +29,7 @@ internal class KtFe10DescLocalVariableSymbol(
         get() = withValidityAssertion { !descriptor.isVar }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
     override val symbolKind: KtSymbolKind
         get() = withValidityAssertion { KtSymbolKind.LOCAL }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt
index 5d0fd3e6380..f238595af5c 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescNamedClassOrObjectSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescNamedClassOrObjectSymbolSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 
 internal class KtFe10DescNamedClassOrObjectSymbol(
     override val descriptor: ClassDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtNamedClassOrObjectSymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -49,7 +49,7 @@ internal class KtFe10DescNamedClassOrObjectSymbol(
         get() {
             withValidityAssertion {
                 val companionObject = descriptor.companionObjectDescriptor ?: return null
-                return KtFe10DescNamedClassOrObjectSymbol(companionObject, analysisSession)
+                return KtFe10DescNamedClassOrObjectSymbol(companionObject, analysisContext)
             }
         }
 
@@ -73,7 +73,7 @@ internal class KtFe10DescNamedClassOrObjectSymbol(
 
     override val superTypes: List<KtTypeAndAnnotations>
         get() = withValidityAssertion {
-            descriptor.getSupertypesWithAny().map { it.toKtTypeAndAnnotations(analysisSession) }
+            descriptor.getSupertypesWithAny().map { it.toKtTypeAndAnnotations(analysisContext) }
         }
 
     override val classIdIfNonLocal: ClassId?
@@ -83,7 +83,7 @@ internal class KtFe10DescNamedClassOrObjectSymbol(
         get() = withValidityAssertion { descriptor.ktSymbolKind }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisContext) } }
 
     override fun createPointer(): KtSymbolPointer<KtNamedClassOrObjectSymbol> = withValidityAssertion {
         val pointerByPsi = KtPsiBasedSymbolPointer.createForSymbolFromSource(this)
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt
index 72cb81f14c0..05fa46c9010 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertyGetterSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
 
 internal class KtFe10DescPropertyGetterSymbol(
     override val descriptor: PropertyGetterDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtPropertyGetterSymbol(), KtFe10DescMemberSymbol<PropertyGetterDescriptor> {
     override val isDefault: Boolean
         get() = withValidityAssertion { descriptor.isDefault }
@@ -38,7 +38,7 @@ internal class KtFe10DescPropertyGetterSymbol(
         get() = withValidityAssertion { descriptor.hasBody() }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
@@ -54,13 +54,13 @@ internal class KtFe10DescPropertyGetterSymbol(
         }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val dispatchType: KtType?
-        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtPropertyGetterSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt
index b8eb84ccb0a..25855e2a317 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescPropertySetterSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.resolve.calls.inference.returnTypeOrNothing
 
 internal class KtFe10DescPropertySetterSymbol(
     override val descriptor: PropertySetterDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtPropertySetterSymbol(), KtFe10DescMemberSymbol<PropertySetterDescriptor> {
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
 
     override val isDefault: Boolean
         get() = withValidityAssertion { descriptor.isDefault }
@@ -41,7 +41,7 @@ internal class KtFe10DescPropertySetterSymbol(
         get() = withValidityAssertion { descriptor.hasBody() }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
@@ -57,13 +57,13 @@ internal class KtFe10DescPropertySetterSymbol(
         }
 
     override val parameter: KtValueParameterSymbol
-        get() = withValidityAssertion { KtFe10DescValueParameterSymbol(descriptor.valueParameters.single(), analysisSession) }
+        get() = withValidityAssertion { KtFe10DescValueParameterSymbol(descriptor.valueParameters.single(), analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val dispatchType: KtType?
-        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> {
         withValidityAssertion {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt
index 44edf0c95c9..82fd1dec1b6 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSamConstructorSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescSamConstructorSymbolPointer
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -24,13 +24,13 @@ import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor
 
 internal class KtFe10DescSamConstructorSymbol(
     override val descriptor: SamConstructorDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtSamConstructorSymbol(), KtFe10DescSymbol<SamConstructorDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { descriptor.ktHasStableParameterNames }
@@ -39,10 +39,10 @@ internal class KtFe10DescSamConstructorSymbol(
         get() = withValidityAssertion { descriptor.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.returnTypeOrNothing.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val isExtension: Boolean
         get() = withValidityAssertion { descriptor.isExtension }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt
index 523bb5dd9da..791642d8f8a 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticFieldSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10DescSyntheticFieldSymbolPointer
@@ -27,16 +27,16 @@ import org.jetbrains.kotlin.resolve.source.getPsi
 
 internal class KtFe10DescSyntheticFieldSymbol(
     private val descriptor: SyntheticFieldDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtBackingFieldSymbol(), KtFe10Symbol {
     override val owningProperty: KtKotlinPropertySymbol
         get() = withValidityAssertion {
             val kotlinProperty = descriptor.propertyDescriptor as PropertyDescriptorImpl
-            KtFe10DescKotlinPropertySymbol(kotlinProperty, analysisSession)
+            KtFe10DescKotlinPropertySymbol(kotlinProperty, analysisContext)
         }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
     override fun createPointer(): KtSymbolPointer<KtVariableLikeSymbol> = withValidityAssertion {
         val accessorPsi = descriptor.containingDeclaration.toSourceElement.getPsi()
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt
index 3245b565c36..731280b5d38 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbol.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
@@ -30,7 +31,7 @@ import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
 
 internal class KtFe10DescSyntheticJavaPropertySymbol(
     override val descriptor: SyntheticJavaPropertyDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtSyntheticJavaPropertySymbol(), KtFe10DescMemberSymbol<SyntheticJavaPropertyDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -52,16 +53,16 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
 
     override val getter: KtPropertyGetterSymbol
         get() = withValidityAssertion {
-            val getter = descriptor.getter ?: return EmptyGetterSymbol(descriptor, analysisSession)
-            return KtFe10DescPropertyGetterSymbol(getter, analysisSession)
+            val getter = descriptor.getter ?: return EmptyGetterSymbol(descriptor, analysisContext)
+            return KtFe10DescPropertyGetterSymbol(getter, analysisContext)
         }
     override val javaGetterSymbol: KtFunctionSymbol
-        get() = withValidityAssertion { KtFe10DescFunctionSymbol(descriptor.getMethod, analysisSession) }
+        get() = withValidityAssertion { KtFe10DescFunctionSymbol(descriptor.getMethod, analysisContext) }
 
     override val javaSetterSymbol: KtFunctionSymbol?
         get() = withValidityAssertion {
             val setMethod = descriptor.setMethod ?: return null
-            return KtFe10DescFunctionSymbol(setMethod, analysisSession)
+            return KtFe10DescFunctionSymbol(setMethod, analysisContext)
         }
 
     override val hasSetter: Boolean
@@ -70,7 +71,7 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
     override val setter: KtPropertySetterSymbol?
         get() = withValidityAssertion {
             val setter = descriptor.setter ?: return null
-            KtFe10DescPropertySetterSymbol(setter, analysisSession)
+            KtFe10DescPropertySetterSymbol(setter, analysisContext)
         }
 
     override val initializer: KtConstantValue?
@@ -80,13 +81,13 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
         get() = withValidityAssertion { descriptor.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val dispatchType: KtType?
-        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val origin: KtSymbolOrigin
         get() = withValidityAssertion { KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY }
@@ -97,7 +98,7 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
 
     private class EmptyGetterSymbol(
         private val descriptor: SyntheticJavaPropertyDescriptor,
-        override val analysisSession: KtFe10AnalysisSession
+        override val analysisContext: Fe10AnalysisContext
     ) : KtPropertyGetterSymbol(), KtFe10Symbol {
         override val isDefault: Boolean
             get() = withValidityAssertion { false }
@@ -121,7 +122,7 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
             get() = withValidityAssertion { null }
 
         override val annotatedType: KtTypeAndAnnotations
-            get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+            get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
         override val origin: KtSymbolOrigin
             get() = withValidityAssertion { KtSymbolOrigin.JAVA }
@@ -130,10 +131,10 @@ internal class KtFe10DescSyntheticJavaPropertySymbol(
             get() = withValidityAssertion { null }
 
         override val receiverType: KtTypeAndAnnotations?
-            get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+            get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
         override val dispatchType: KtType?
-            get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+            get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
         override val modality: Modality
             get() = withValidityAssertion { Modality.FINAL }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt
index 343fc2c6733..d9c63b832da 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescSyntheticJavaPropertySymbolForOverride.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.*
@@ -30,7 +31,7 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension
 
 internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
     override val descriptor: JavaForKotlinOverridePropertyDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtSyntheticJavaPropertySymbol(), KtFe10DescMemberSymbol<JavaForKotlinOverridePropertyDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
@@ -52,16 +53,16 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
 
     override val getter: KtPropertyGetterSymbol
         get() = withValidityAssertion {
-            val getter = descriptor.getter ?: return EmptyGetterSymbol(descriptor, analysisSession)
-            return KtFe10DescPropertyGetterSymbol(getter, analysisSession)
+            val getter = descriptor.getter ?: return EmptyGetterSymbol(descriptor, analysisContext)
+            return KtFe10DescPropertyGetterSymbol(getter, analysisContext)
         }
     override val javaGetterSymbol: KtFunctionSymbol
-        get() = withValidityAssertion { KtFe10DescFunctionSymbol(descriptor.getterMethod, analysisSession) }
+        get() = withValidityAssertion { KtFe10DescFunctionSymbol(descriptor.getterMethod, analysisContext) }
 
     override val javaSetterSymbol: KtFunctionSymbol?
         get() = withValidityAssertion {
             val setMethod = descriptor.setterMethod ?: return null
-            return KtFe10DescFunctionSymbol(setMethod, analysisSession)
+            return KtFe10DescFunctionSymbol(setMethod, analysisContext)
         }
 
     override val hasSetter: Boolean
@@ -70,7 +71,7 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
     override val setter: KtPropertySetterSymbol?
         get() = withValidityAssertion {
             val setter = descriptor.setter ?: return null
-            KtFe10DescPropertySetterSymbol(setter, analysisSession)
+            KtFe10DescPropertySetterSymbol(setter, analysisContext)
         }
 
     override val initializer: KtConstantValue?
@@ -80,13 +81,13 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
         get() = withValidityAssertion { descriptor.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
     override val receiverType: KtTypeAndAnnotations?
-        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+        get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
     override val dispatchType: KtType?
-        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
     override val origin: KtSymbolOrigin
         get() = withValidityAssertion { KtSymbolOrigin.JAVA_SYNTHETIC_PROPERTY }
@@ -97,7 +98,7 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
 
     private class EmptyGetterSymbol(
         private val descriptor: JavaForKotlinOverridePropertyDescriptor,
-        override val analysisSession: KtFe10AnalysisSession
+        override val analysisContext: Fe10AnalysisContext
     ) : KtPropertyGetterSymbol(), KtFe10Symbol {
         override val isDefault: Boolean
             get() = withValidityAssertion { false }
@@ -121,7 +122,7 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
             get() = withValidityAssertion { null }
 
         override val annotatedType: KtTypeAndAnnotations
-            get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisSession) }
+            get() = withValidityAssertion { descriptor.type.toKtTypeAndAnnotations(analysisContext) }
 
         override val origin: KtSymbolOrigin
             get() = withValidityAssertion { KtSymbolOrigin.JAVA }
@@ -130,10 +131,10 @@ internal class KtFe10DescSyntheticJavaPropertySymbolForOverride(
             get() = withValidityAssertion { null }
 
         override val receiverType: KtTypeAndAnnotations?
-            get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) }
+            get() = withValidityAssertion { descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) }
 
         override val dispatchType: KtType?
-            get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession) }
+            get() = withValidityAssertion { descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext) }
 
         override val modality: Modality
             get() = withValidityAssertion { Modality.FINAL }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt
index deaad1c88eb..cf5aa6d2915 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeAliasSymbol.kt
@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -24,19 +24,19 @@ import org.jetbrains.kotlin.name.Name
 
 internal class KtFe10DescTypeAliasSymbol(
     override val descriptor: TypeAliasDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtTypeAliasSymbol(), KtFe10DescSymbol<TypeAliasDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { descriptor.declaredTypeParameters.map { KtFe10DescTypeParameterSymbol(it, analysisContext) } }
 
     override val visibility: Visibility
         get() = withValidityAssertion { descriptor.ktVisibility }
 
     override val expandedType: KtType
-        get() = withValidityAssertion { descriptor.expandedType.toKtType(analysisSession) }
+        get() = withValidityAssertion { descriptor.expandedType.toKtType(analysisContext) }
 
     override val classIdIfNonLocal: ClassId?
         get() = withValidityAssertion { descriptor.classId }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt
index 972b43dcb6f..b00f14b2336 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescTypeParameterSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
@@ -20,13 +21,13 @@ import org.jetbrains.kotlin.types.Variance
 
 internal class KtFe10DescTypeParameterSymbol(
     override val descriptor: TypeParameterDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtTypeParameterSymbol(), KtFe10DescSymbol<TypeParameterDescriptor> {
     override val name: Name
         get() = withValidityAssertion { descriptor.name }
 
     override val upperBounds: List<KtType>
-        get() = withValidityAssertion { descriptor.upperBounds.map { it.toKtType(analysisSession) } }
+        get() = withValidityAssertion { descriptor.upperBounds.map { it.toKtType(analysisContext) } }
 
     override val variance: Variance
         get() = withValidityAssertion { descriptor.variance }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt
index 167e2a125f0..bb4accde611 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/KtFe10DescValueParameterSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.KtFe10DescSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -22,7 +23,7 @@ import org.jetbrains.kotlin.resolve.calls.components.isVararg
 
 internal class KtFe10DescValueParameterSymbol(
     override val descriptor: ValueParameterDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtValueParameterSymbol(), KtFe10DescSymbol<ValueParameterDescriptor> {
     override val name: Name
         get() = withValidityAssertion {
@@ -40,7 +41,7 @@ internal class KtFe10DescValueParameterSymbol(
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            return (descriptor.varargElementType ?: descriptor.type).toKtTypeAndAnnotations(analysisSession)
+            return (descriptor.varargElementType ?: descriptor.type).toKtTypeAndAnnotations(analysisContext)
         }
 
     override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> = withValidityAssertion {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt
index b7bd2b65474..46558817e80 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/descriptorBased/base/Kt1DescUtils.kt
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.analysis.api.KtStarProjectionTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
 import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.*
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
@@ -62,41 +63,41 @@ internal val ClassDescriptor.isInterfaceLike: Boolean
         else -> true
     }
 
-internal fun DeclarationDescriptor.toKtSymbol(analysisSession: KtFe10AnalysisSession): KtSymbol? {
+internal fun DeclarationDescriptor.toKtSymbol(analysisContext: Fe10AnalysisContext): KtSymbol? {
     if (this is ClassDescriptor && kind == ClassKind.ENUM_ENTRY) {
-        return KtFe10DescEnumEntrySymbol(this, analysisSession)
+        return KtFe10DescEnumEntrySymbol(this, analysisContext)
     }
 
     return when (this) {
-        is ClassifierDescriptor -> toKtClassifierSymbol(analysisSession)
-        is CallableDescriptor -> toKtCallableSymbol(analysisSession)
+        is ClassifierDescriptor -> toKtClassifierSymbol(analysisContext)
+        is CallableDescriptor -> toKtCallableSymbol(analysisContext)
         else -> null
     }
 }
 
-internal fun ClassifierDescriptor.toKtClassifierSymbol(analysisSession: KtFe10AnalysisSession): KtClassifierSymbol? {
+internal fun ClassifierDescriptor.toKtClassifierSymbol(analysisContext: Fe10AnalysisContext): KtClassifierSymbol? {
     return when (this) {
-        is TypeAliasDescriptor -> KtFe10DescTypeAliasSymbol(this, analysisSession)
-        is TypeParameterDescriptor -> KtFe10DescTypeParameterSymbol(this, analysisSession)
-        is ClassDescriptor -> toKtClassSymbol(analysisSession)
+        is TypeAliasDescriptor -> KtFe10DescTypeAliasSymbol(this, analysisContext)
+        is TypeParameterDescriptor -> KtFe10DescTypeParameterSymbol(this, analysisContext)
+        is ClassDescriptor -> toKtClassSymbol(analysisContext)
         else -> null
     }
 }
 
-internal fun ClassDescriptor.toKtClassSymbol(analysisSession: KtFe10AnalysisSession): KtClassOrObjectSymbol? {
+internal fun ClassDescriptor.toKtClassSymbol(analysisContext: Fe10AnalysisContext): KtClassOrObjectSymbol {
     return if (DescriptorUtils.isAnonymousObject(this)) {
-        KtFe10DescAnonymousObjectSymbol(this, analysisSession)
+        KtFe10DescAnonymousObjectSymbol(this, analysisContext)
     } else {
-        KtFe10DescNamedClassOrObjectSymbol(this, analysisSession)
+        KtFe10DescNamedClassOrObjectSymbol(this, analysisContext)
     }
 }
 
-internal fun ConstructorDescriptor.toKtConstructorSymbol(analysisSession: KtFe10AnalysisSession): KtConstructorSymbol {
+internal fun ConstructorDescriptor.toKtConstructorSymbol(analysisContext: Fe10AnalysisContext): KtConstructorSymbol {
     if (this is TypeAliasConstructorDescriptor) {
-        return this.underlyingConstructorDescriptor.toKtConstructorSymbol(analysisSession)
+        return this.underlyingConstructorDescriptor.toKtConstructorSymbol(analysisContext)
     }
 
-    return KtFe10DescConstructorSymbol(this, analysisSession)
+    return KtFe10DescConstructorSymbol(this, analysisContext)
 }
 
 internal val CallableMemberDescriptor.ktHasStableParameterNames: Boolean
@@ -109,41 +110,41 @@ internal val CallableMemberDescriptor.ktHasStableParameterNames: Boolean
         }
     }
 
-internal fun CallableDescriptor.toKtCallableSymbol(analysisSession: KtFe10AnalysisSession): KtCallableSymbol? {
+internal fun CallableDescriptor.toKtCallableSymbol(analysisContext: Fe10AnalysisContext): KtCallableSymbol? {
     return when (this) {
-        is PropertyGetterDescriptor -> KtFe10DescPropertyGetterSymbol(this, analysisSession)
-        is PropertySetterDescriptor -> KtFe10DescPropertySetterSymbol(this, analysisSession)
-        is SamConstructorDescriptor -> KtFe10DescSamConstructorSymbol(this, analysisSession)
-        is ConstructorDescriptor -> toKtConstructorSymbol(analysisSession)
+        is PropertyGetterDescriptor -> KtFe10DescPropertyGetterSymbol(this, analysisContext)
+        is PropertySetterDescriptor -> KtFe10DescPropertySetterSymbol(this, analysisContext)
+        is SamConstructorDescriptor -> KtFe10DescSamConstructorSymbol(this, analysisContext)
+        is ConstructorDescriptor -> toKtConstructorSymbol(analysisContext)
         is FunctionDescriptor -> {
             if (DescriptorUtils.isAnonymousFunction(this)) {
-                KtFe10DescAnonymousFunctionSymbol(this, analysisSession)
+                KtFe10DescAnonymousFunctionSymbol(this, analysisContext)
             } else {
-                KtFe10DescFunctionSymbol(this, analysisSession)
+                KtFe10DescFunctionSymbol(this, analysisContext)
             }
         }
-        is SyntheticFieldDescriptor -> KtFe10DescSyntheticFieldSymbol(this, analysisSession)
-        is LocalVariableDescriptor -> KtFe10DescLocalVariableSymbol(this, analysisSession)
-        is ValueParameterDescriptor -> KtFe10DescValueParameterSymbol(this, analysisSession)
-        is SyntheticJavaPropertyDescriptor -> KtFe10DescSyntheticJavaPropertySymbol(this, analysisSession)
-        is JavaForKotlinOverridePropertyDescriptor -> KtFe10DescSyntheticJavaPropertySymbolForOverride(this, analysisSession)
-        is JavaPropertyDescriptor -> KtFe10DescJavaFieldSymbol(this, analysisSession)
-        is PropertyDescriptorImpl -> KtFe10DescKotlinPropertySymbol(this, analysisSession)
+        is SyntheticFieldDescriptor -> KtFe10DescSyntheticFieldSymbol(this, analysisContext)
+        is LocalVariableDescriptor -> KtFe10DescLocalVariableSymbol(this, analysisContext)
+        is ValueParameterDescriptor -> KtFe10DescValueParameterSymbol(this, analysisContext)
+        is SyntheticJavaPropertyDescriptor -> KtFe10DescSyntheticJavaPropertySymbol(this, analysisContext)
+        is JavaForKotlinOverridePropertyDescriptor -> KtFe10DescSyntheticJavaPropertySymbolForOverride(this, analysisContext)
+        is JavaPropertyDescriptor -> KtFe10DescJavaFieldSymbol(this, analysisContext)
+        is PropertyDescriptorImpl -> KtFe10DescKotlinPropertySymbol(this, analysisContext)
         else -> null
     }
 }
 
-internal fun KotlinType.toKtType(analysisSession: KtFe10AnalysisSession): KtType {
+internal fun KotlinType.toKtType(analysisContext: Fe10AnalysisContext): KtType {
     return when (val unwrappedType = unwrap()) {
-        is FlexibleType -> KtFe10FlexibleType(unwrappedType, analysisSession)
-        is DefinitelyNotNullType -> KtFe10DefinitelyNotNullType(unwrappedType, analysisSession)
-        is ErrorType -> KtFe10ClassErrorType(unwrappedType, analysisSession)
-        is CapturedType -> KtFe10CapturedType(unwrappedType, analysisSession)
-        is NewCapturedType -> KtFe10NewCapturedType(unwrappedType, analysisSession)
+        is FlexibleType -> KtFe10FlexibleType(unwrappedType, analysisContext)
+        is DefinitelyNotNullType -> KtFe10DefinitelyNotNullType(unwrappedType, analysisContext)
+        is ErrorType -> KtFe10ClassErrorType(unwrappedType, analysisContext)
+        is CapturedType -> KtFe10CapturedType(unwrappedType, analysisContext)
+        is NewCapturedType -> KtFe10NewCapturedType(unwrappedType, analysisContext)
         is SimpleType -> {
             val typeParameterDescriptor = TypeUtils.getTypeParameterDescriptorOrNull(unwrappedType)
             if (typeParameterDescriptor != null) {
-                return KtFe10TypeParameterType(unwrappedType, typeParameterDescriptor, analysisSession)
+                return KtFe10TypeParameterType(unwrappedType, typeParameterDescriptor, analysisContext)
             }
 
             val typeConstructor = unwrappedType.constructor
@@ -151,22 +152,22 @@ internal fun KotlinType.toKtType(analysisSession: KtFe10AnalysisSession): KtType
             if (typeConstructor is NewTypeVariableConstructor) {
                 val newTypeParameterDescriptor = typeConstructor.originalTypeParameter
                 return if (newTypeParameterDescriptor != null) {
-                    KtFe10TypeParameterType(unwrappedType, newTypeParameterDescriptor, analysisSession)
+                    KtFe10TypeParameterType(unwrappedType, newTypeParameterDescriptor, analysisContext)
                 } else {
-                    KtFe10ClassErrorType(ErrorUtils.createErrorType("Unresolved type parameter type") as ErrorType, analysisSession)
+                    KtFe10ClassErrorType(ErrorUtils.createErrorType("Unresolved type parameter type") as ErrorType, analysisContext)
                 }
             }
 
             if (typeConstructor is IntersectionTypeConstructor) {
-                return KtFe10IntersectionType(unwrappedType, typeConstructor.supertypes, analysisSession)
+                return KtFe10IntersectionType(unwrappedType, typeConstructor.supertypes, analysisContext)
             }
 
             return when (val typeDeclaration = typeConstructor.declarationDescriptor) {
-                is FunctionClassDescriptor -> KtFe10FunctionalType(unwrappedType, typeDeclaration, analysisSession)
-                is ClassDescriptor -> KtFe10UsualClassType(unwrappedType, typeDeclaration, analysisSession)
+                is FunctionClassDescriptor -> KtFe10FunctionalType(unwrappedType, typeDeclaration, analysisContext)
+                is ClassDescriptor -> KtFe10UsualClassType(unwrappedType, typeDeclaration, analysisContext)
                 else -> {
                     val errorType = ErrorUtils.createErrorTypeWithCustomConstructor("Unresolved class type", typeConstructor)
-                    KtFe10ClassErrorType(errorType as ErrorType, analysisSession)
+                    KtFe10ClassErrorType(errorType as ErrorType, analysisContext)
                 }
             }
 
@@ -175,15 +176,15 @@ internal fun KotlinType.toKtType(analysisSession: KtFe10AnalysisSession): KtType
     }
 }
 
-internal fun KotlinType.toKtTypeAndAnnotations(analysisSession: KtFe10AnalysisSession): KtTypeAndAnnotations {
-    return KtFe10TypeAndAnnotations(toKtType(analysisSession), this, analysisSession.token)
+internal fun KotlinType.toKtTypeAndAnnotations(analysisContext: Fe10AnalysisContext): KtTypeAndAnnotations {
+    return KtFe10TypeAndAnnotations(toKtType(analysisContext), this, analysisContext.token)
 }
 
-internal fun TypeProjection.toKtTypeArgument(analysisSession: KtFe10AnalysisSession): KtTypeArgument {
+internal fun TypeProjection.toKtTypeArgument(analysisContext: Fe10AnalysisContext): KtTypeArgument {
     return if (isStarProjection) {
-        KtStarProjectionTypeArgument(analysisSession.token)
+        KtStarProjectionTypeArgument(analysisContext.token)
     } else {
-        KtTypeArgumentWithVariance(type.toKtType(analysisSession), this.projectionKind, analysisSession.token)
+        KtTypeArgumentWithVariance(type.toKtType(analysisContext), this.projectionKind, analysisContext.token)
     }
 }
 
@@ -288,13 +289,13 @@ internal fun ClassDescriptor.getSupertypesWithAny(): Collection<KotlinType> {
     return if (hasClassSupertype) supertypes else listOf(builtIns.anyType) + supertypes
 }
 
-internal fun DeclarationDescriptor.render(analysisSession: KtFe10AnalysisSession, options: KtDeclarationRendererOptions): String {
-    val renderer = KtFe10Renderer(analysisSession, options)
+internal fun DeclarationDescriptor.render(analysisContext: Fe10AnalysisContext, options: KtDeclarationRendererOptions): String {
+    val renderer = KtFe10Renderer(analysisContext, options)
     val consumer = StringBuilder()
     renderer.render(this, consumer)
     return consumer.toString().trim()
 }
 
-internal fun CallableMemberDescriptor.getSymbolPointerSignature(analysisSession: KtFe10AnalysisSession): String {
-    return render(analysisSession, KtDeclarationRendererOptions.DEFAULT)
+internal fun CallableMemberDescriptor.getSymbolPointerSignature(analysisContext: Fe10AnalysisContext): String {
+    return render(analysisContext, KtDeclarationRendererOptions.DEFAULT)
 }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt
index d6aaaa0b6d9..b1fd4d14761 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescEnumEntrySymbolPointer.kt
@@ -21,12 +21,14 @@ class KtFe10DescEnumEntrySymbolPointer(private val classId: ClassId, private val
     @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtEnumEntrySymbol? {
         check(analysisSession is KtFe10AnalysisSession)
-        val entryDescriptor = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
+        val analysisContext = analysisSession.analysisContext
+
+        val entryDescriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
             ?.unsubstitutedMemberScope
             ?.getContributedClassifier(entryName, NoLookupLocation.FROM_IDE)
 
         if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) {
-            return KtFe10DescEnumEntrySymbol(entryDescriptor, analysisSession)
+            return KtFe10DescEnumEntrySymbol(entryDescriptor, analysisContext)
         }
 
         return null
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt
index bb4baf88740..2369e958c31 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescFunctionLikeSymbolPointer.kt
@@ -25,22 +25,23 @@ class KtFe10DescFunctionLikeSymbolPointer<T : KtFunctionLikeSymbol>(
     @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
     override fun restoreSymbol(analysisSession: KtAnalysisSession): T? {
         check(analysisSession is KtFe10AnalysisSession)
+        val analysisContext = analysisSession.analysisContext
 
         val className = callableId.className
         val memberScope = if (className != null) {
             val outerClassId = ClassId(callableId.packageName, className, false)
-            analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(outerClassId)
+            analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(outerClassId)
                 ?.unsubstitutedMemberScope
                 ?: MemberScope.Empty
         } else {
-            analysisSession.resolveSession.moduleDescriptor.getPackage(callableId.packageName).memberScope
+            analysisContext.resolveSession.moduleDescriptor.getPackage(callableId.packageName).memberScope
         }
 
         @Suppress("UNCHECKED_CAST")
         return memberScope
             .getContributedDescriptors(DescriptorKindFilter.CALLABLES) { it == callableId.callableName }
             .filterIsInstance<CallableMemberDescriptor>()
-            .firstOrNull { it.getSymbolPointerSignature(analysisSession) == signature }
-            ?.toKtCallableSymbol(analysisSession) as? T
+            .firstOrNull { it.getSymbolPointerSignature(analysisContext) == signature }
+            ?.toKtCallableSymbol(analysisContext) as? T
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt
index 2867e507c20..134bba943de 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescNamedClassOrObjectSymbolSymbol.kt
@@ -17,7 +17,9 @@ class KtFe10DescNamedClassOrObjectSymbolSymbol(private val classId: ClassId) : K
     @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtNamedClassOrObjectSymbol? {
         check(analysisSession is KtFe10AnalysisSession)
-        val descriptor = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
-        return KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisSession)
+        val analysisContext = analysisSession.analysisContext
+
+        val descriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
+        return KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisContext)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt
index 213e1ad4c70..9b60dbbecdb 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSamConstructorSymbolPointer.kt
@@ -20,7 +20,9 @@ class KtFe10DescSamConstructorSymbolPointer(private val classId: ClassId) : KtSy
     @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtSamConstructorSymbol? {
         check(analysisSession is KtFe10AnalysisSession)
-        val samInterface = analysisSession.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
+        val analysisContext = analysisSession.analysisContext
+
+        val samInterface = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId)
         if (samInterface == null || getSingleAbstractMethodOrNull(samInterface) == null) {
             return null
         }
@@ -28,10 +30,10 @@ class KtFe10DescSamConstructorSymbolPointer(private val classId: ClassId) : KtSy
         val constructorDescriptor = createSamConstructorFunction(
             samInterface.containingDeclaration,
             samInterface,
-            analysisSession.resolveSession.samConversionResolver,
-            JvmSamConversionOracle(analysisSession.resolveSession.languageVersionSettings)
+            analysisContext.resolveSession.samConversionResolver,
+            JvmSamConversionOracle(analysisContext.resolveSession.languageVersionSettings)
         )
 
-        return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisSession)
+        return KtFe10DescSamConstructorSymbol(constructorDescriptor, analysisContext)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt
index f3d9ca665db..fc9f23d1db6 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10DescSyntheticFieldSymbolPointer.kt
@@ -22,12 +22,13 @@ class KtFe10DescSyntheticFieldSymbolPointer(
     @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtBackingFieldSymbol? {
         check(analysisSession is KtFe10AnalysisSession)
+        val analysisContext = analysisSession.analysisContext
 
         @Suppress("DEPRECATION")
         val accessorSymbol = psiPointer.restoreSymbol(analysisSession) ?: return null
 
         val accessorDescriptor = getSymbolDescriptor(accessorSymbol) as? PropertyAccessorDescriptor ?: return null
         val syntheticFieldDescriptor = SyntheticFieldDescriptor(accessorDescriptor, accessorDescriptor.correspondingProperty.source)
-        return KtFe10DescSyntheticFieldSymbol(syntheticFieldDescriptor, analysisSession)
+        return KtFe10DescSyntheticFieldSymbol(syntheticFieldDescriptor, analysisContext)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt
index f00ca572b15..bcfb4133fbe 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/pointers/KtFe10PackageSymbolPointer.kt
@@ -16,6 +16,6 @@ internal class KtFe10PackageSymbolPointer(private val packageName: FqName) : KtS
     @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KtAnalysisSession.restoreSymbol")
     override fun restoreSymbol(analysisSession: KtAnalysisSession): KtPackageSymbol {
         check(analysisSession is KtFe10AnalysisSession)
-        return KtFe10PackageSymbol(packageName, analysisSession)
+        return KtFe10PackageSymbol(packageName, analysisSession.analysisContext)
     }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt
index 0bdba1980db..cc4053a993e 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousFunctionSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -25,27 +26,27 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiAnonymousFunctionSymbol(
     override val psi: KtNamedFunction,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtAnonymousFunctionSymbol(), KtFe10PsiSymbol<KtNamedFunction, FunctionDescriptor> {
     override val descriptor: FunctionDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.FUNCTION, psi]
     }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val receiverType: KtTypeAndAnnotations?
         get() = withValidityAssertion {
-            descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val isExtension: Boolean
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt
index 0061a6b5ed3..b8096d98e94 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiAnonymousObjectSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -22,16 +23,16 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiAnonymousObjectSymbol(
     override val psi: KtObjectDeclaration,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtAnonymousObjectSymbol(), KtFe10PsiSymbol<KtObjectDeclaration, ClassDescriptor> {
     override val descriptor: ClassDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.CLASS, psi]
     }
 
     override val superTypes: List<KtTypeAndAnnotations>
         get() = withValidityAssertion {
-            descriptor?.typeConstructor?.supertypes?.map { it.toKtTypeAndAnnotations(analysisSession) } ?: emptyList()
+            descriptor?.typeConstructor?.supertypes?.map { it.toKtTypeAndAnnotations(analysisContext) } ?: emptyList()
         }
 
     override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt
index 810eaf5b1a0..5987fa60564 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiClassInitializerSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -18,7 +19,7 @@ import org.jetbrains.kotlin.psi.KtClassInitializer
 
 class KtFe10PsiClassInitializerSymbol(
     override val psi: KtClassInitializer,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtClassInitializerSymbol(), KtFe10Symbol {
     override val origin: KtSymbolOrigin
         get() = withValidityAssertion {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt
index 5aedeb1b889..197c5f99a2f 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiConstructorSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -34,10 +35,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiConstructorSymbol(
     override val psi: KtConstructor<*>,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtConstructorSymbol(), KtFe10PsiSymbol<KtConstructor<*>, ConstructorDescriptor> {
     override val descriptor: ConstructorDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.CONSTRUCTOR, psi]
     }
 
@@ -48,27 +49,27 @@ internal class KtFe10PsiConstructorSymbol(
         get() = withValidityAssertion { psi.getContainingClassOrObject().getClassId() }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val dispatchType: KtType?
         get() = withValidityAssertion {
             val containingClass = descriptor?.constructedClass?.containingDeclaration as? ClassDescriptor ?: return null
-            return containingClass.defaultType.toKtType(analysisSession)
+            return containingClass.defaultType.toKtType(analysisContext)
         }
 
     override val visibility: Visibility
         get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisContext) } }
 
     override fun createPointer(): KtSymbolPointer<KtConstructorSymbol> = withValidityAssertion {
         return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt
index d32976e46c4..dc7a386e899 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiDefaultSetterParameterSymbol.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
@@ -27,10 +28,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiDefaultSetterParameterSymbol(
     private val accessorPsi: KtPropertyAccessor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtValueParameterSymbol(), KtFe10Symbol {
     private val descriptor: VariableDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(accessorPsi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(accessorPsi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.PROPERTY_ACCESSOR, accessorPsi]?.valueParameters?.single()
     }
 
@@ -44,7 +45,7 @@ internal class KtFe10PsiDefaultSetterParameterSymbol(
         get() = withValidityAssertion { false }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
 
     override val psi: PsiElement?
         get() = withValidityAssertion { null }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt
index a6a40bf0487..eb9549bae20 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiEnumEntrySymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -28,10 +29,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiEnumEntrySymbol(
     override val psi: KtEnumEntry,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtEnumEntrySymbol(), KtFe10PsiSymbol<KtEnumEntry, ClassDescriptor> {
     override val descriptor: ClassDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.CLASS, psi]
     }
 
@@ -46,7 +47,7 @@ internal class KtFe10PsiEnumEntrySymbol(
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            descriptor?.defaultType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.defaultType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val name: Name
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt
index 6917403f425..6996697812e 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiFunctionSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -37,10 +38,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiFunctionSymbol(
     override val psi: KtNamedFunction,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFunctionSymbol(), KtFe10PsiSymbol<KtNamedFunction, FunctionDescriptor> {
     override val descriptor: FunctionDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.FUNCTION, psi]
     }
 
@@ -66,7 +67,7 @@ internal class KtFe10PsiFunctionSymbol(
         get() = withValidityAssertion { false }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
@@ -75,12 +76,12 @@ internal class KtFe10PsiFunctionSymbol(
         get() = withValidityAssertion { psi.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
 
     override val receiverType: KtTypeAndAnnotations?
         get() = withValidityAssertion {
             return if (psi.isExtensionDeclaration()) {
-                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
             } else {
                 null
             }
@@ -102,11 +103,11 @@ internal class KtFe10PsiFunctionSymbol(
                 return null
             }
 
-            return descriptor?.dispatchReceiverParameter?.type?.toKtType(analysisSession) ?: createErrorType()
+            return descriptor?.dispatchReceiverParameter?.type?.toKtType(analysisContext) ?: createErrorType()
         }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisContext) } }
 
     override val modality: Modality
         get() = withValidityAssertion { psi.ktModality ?: descriptor?.modality ?: Modality.FINAL }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt
index 80e0bcc1134..ed4d4cf1aea 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiKotlinPropertySymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -37,10 +38,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiKotlinPropertySymbol(
     override val psi: KtProperty,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtKotlinPropertySymbol(), KtFe10PsiSymbol<KtProperty, PropertyDescriptor> {
     override val descriptor: PropertyDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.VARIABLE, psi] as? PropertyDescriptor
     }
 
@@ -59,18 +60,18 @@ internal class KtFe10PsiKotlinPropertySymbol(
     override val getter: KtPropertyGetterSymbol?
         get() = withValidityAssertion {
             val getter = psi.getter ?: return null
-            return KtFe10PsiPropertyGetterSymbol(getter, analysisSession)
+            return KtFe10PsiPropertyGetterSymbol(getter, analysisContext)
         }
 
     override val setter: KtPropertySetterSymbol?
         get() = withValidityAssertion {
             val setter = psi.setter ?: return null
-            return KtFe10PsiPropertySetterSymbol(setter, analysisSession)
+            return KtFe10PsiPropertySetterSymbol(setter, analysisContext)
         }
 
     override val hasBackingField: Boolean
         get() = withValidityAssertion {
-            val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+            val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
             bindingContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] == true
         }
 
@@ -98,12 +99,12 @@ internal class KtFe10PsiKotlinPropertySymbol(
         get() = withValidityAssertion { psi.callableId }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
 
     override val receiverType: KtTypeAndAnnotations?
         get() = withValidityAssertion {
             return if (psi.isExtensionDeclaration()) {
-                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+                descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
             } else {
                 null
             }
@@ -121,7 +122,7 @@ internal class KtFe10PsiKotlinPropertySymbol(
     override val dispatchType: KtType?
         get() = withValidityAssertion {
             return if (!isStatic) {
-                descriptor?.dispatchReceiverParameter?.type?.toKtType(analysisSession) ?: createErrorType()
+                descriptor?.dispatchReceiverParameter?.type?.toKtType(analysisContext) ?: createErrorType()
             } else {
                 null
             }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt
index adb93cbfff6..a9186b2b834 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLiteralAnonymousFunctionSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -24,27 +25,27 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiLiteralAnonymousFunctionSymbol(
     override val psi: KtFunctionLiteral,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtAnonymousFunctionSymbol(), KtFe10PsiSymbol<KtFunctionLiteral, FunctionDescriptor> {
     override val descriptor: FunctionDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi)
+        val bindingContext = analysisContext.analyze(psi)
         bindingContext[BindingContext.FUNCTION, psi]
     }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val receiverType: KtTypeAndAnnotations?
         get() = withValidityAssertion {
-            descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val isExtension: Boolean
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt
index a041bf0ddfa..458b4cb8c98 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiLocalVariableSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -25,10 +26,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiLocalVariableSymbol(
     override val psi: KtVariableDeclaration,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtLocalVariableSymbol(), KtFe10PsiSymbol<KtVariableDeclaration, VariableDescriptor> {
     override val descriptor: VariableDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.VARIABLE, psi]
     }
 
@@ -36,7 +37,7 @@ internal class KtFe10PsiLocalVariableSymbol(
         get() = withValidityAssertion { psi.nameAsSafeName }
 
     override val annotatedType: KtTypeAndAnnotations
-        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations() }
+        get() = withValidityAssertion { descriptor?.type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations() }
 
     override val isVal: Boolean
         get() = withValidityAssertion { !psi.isVar }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt
index 1b5cf9eca79..65e501604ba 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiNamedClassOrObjectSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSupertypesWithAny
@@ -39,10 +40,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiNamedClassOrObjectSymbol(
     override val psi: KtClassOrObject,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtNamedClassOrObjectSymbol(), KtFe10PsiSymbol<KtClassOrObject, ClassDescriptor> {
     override val descriptor: ClassDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.CLASS, psi]
     }
 
@@ -64,7 +65,7 @@ internal class KtFe10PsiNamedClassOrObjectSymbol(
     override val companionObject: KtNamedClassOrObjectSymbol?
         get() = withValidityAssertion {
             val companionObject = psi.companionObjects.firstOrNull() ?: return null
-            KtFe10PsiNamedClassOrObjectSymbol(companionObject, analysisSession)
+            KtFe10PsiNamedClassOrObjectSymbol(companionObject, analysisContext)
         }
 
     override val classKind: KtClassKind
@@ -88,7 +89,7 @@ internal class KtFe10PsiNamedClassOrObjectSymbol(
 
     override val superTypes: List<KtTypeAndAnnotations>
         get() = withValidityAssertion {
-            descriptor?.getSupertypesWithAny()?.map { it.toKtTypeAndAnnotations(analysisSession) } ?: emptyList()
+            descriptor?.getSupertypesWithAny()?.map { it.toKtTypeAndAnnotations(analysisContext) } ?: emptyList()
         }
 
     override val classIdIfNonLocal: ClassId?
@@ -101,7 +102,7 @@ internal class KtFe10PsiNamedClassOrObjectSymbol(
         get() = withValidityAssertion { psi.ktSymbolKind }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisContext) } }
 
     override val modality: Modality
         get() = withValidityAssertion { psi.ktModality ?: descriptor?.modality ?: Modality.FINAL }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt
index 09b312727d0..c8dab8e47c7 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertyGetterSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -31,10 +32,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiPropertyGetterSymbol(
     override val psi: KtPropertyAccessor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtPropertyGetterSymbol(), KtFe10PsiSymbol<KtPropertyAccessor, PropertyGetterDescriptor> {
     override val descriptor: PropertyGetterDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.PROPERTY_ACCESSOR, psi] as? PropertyGetterDescriptor
     }
 
@@ -57,7 +58,7 @@ internal class KtFe10PsiPropertyGetterSymbol(
         get() = withValidityAssertion { psi.hasBody() }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
@@ -67,13 +68,13 @@ internal class KtFe10PsiPropertyGetterSymbol(
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
     override val receiverType: KtTypeAndAnnotations?
         get() = withValidityAssertion {
             val descriptor = this.descriptor
             return when {
-                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession)
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext)
                 !psi.property.isTopLevel -> createErrorTypeAndAnnotations()
                 else -> null
             }
@@ -83,7 +84,7 @@ internal class KtFe10PsiPropertyGetterSymbol(
         get() = withValidityAssertion {
             val descriptor = this.descriptor
             return when {
-                descriptor != null -> descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession)
+                descriptor != null -> descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext)
                 !psi.property.isTopLevel -> createErrorType()
                 else -> null
             }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt
index e2971440379..908af092a37 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiPropertySetterSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -32,10 +33,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiPropertySetterSymbol(
     override val psi: KtPropertyAccessor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtPropertySetterSymbol(), KtFe10PsiSymbol<KtPropertyAccessor, PropertySetterDescriptor> {
     override val descriptor: PropertySetterDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.PROPERTY_ACCESSOR, psi] as? PropertySetterDescriptor
     }
 
@@ -58,7 +59,7 @@ internal class KtFe10PsiPropertySetterSymbol(
         get() = withValidityAssertion { psi.hasBody() }
 
     override val valueParameters: List<KtValueParameterSymbol>
-        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
 
     override val hasStableParameterNames: Boolean
         get() = withValidityAssertion { true }
@@ -68,13 +69,13 @@ internal class KtFe10PsiPropertySetterSymbol(
 
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
-            descriptor?.returnType?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            descriptor?.returnType?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
     override val receiverType: KtTypeAndAnnotations?
         get() = withValidityAssertion {
             val descriptor = this.descriptor
             return when {
-                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisSession)
+                descriptor != null -> descriptor.extensionReceiverParameter?.type?.toKtTypeAndAnnotations(analysisContext)
                 psi.property.isExtensionDeclaration() -> createErrorTypeAndAnnotations()
                 else -> null
             }
@@ -84,7 +85,7 @@ internal class KtFe10PsiPropertySetterSymbol(
         get() = withValidityAssertion {
             val descriptor = this.descriptor
             return when {
-                descriptor != null -> descriptor.dispatchReceiverParameter?.type?.toKtType(analysisSession)
+                descriptor != null -> descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext)
                 !psi.property.isTopLevel -> createErrorType()
                 else -> null
             }
@@ -94,9 +95,9 @@ internal class KtFe10PsiPropertySetterSymbol(
         get() = withValidityAssertion {
             val parameter = psi.parameter
             return if (parameter != null) {
-                KtFe10PsiValueParameterSymbol(parameter, analysisSession)
+                KtFe10PsiValueParameterSymbol(parameter, analysisContext)
             } else {
-                KtFe10PsiDefaultSetterParameterSymbol(psi, analysisSession)
+                KtFe10PsiDefaultSetterParameterSymbol(psi, analysisContext)
             }
         }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt
index 35f5ad902f0..6d33e60df6a 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeAliasSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
@@ -29,10 +30,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiTypeAliasSymbol(
     override val psi: KtTypeAlias,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtTypeAliasSymbol(), KtFe10PsiSymbol<KtTypeAlias, TypeAliasDescriptor> {
     override val descriptor: TypeAliasDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi)
+        val bindingContext = analysisContext.analyze(psi)
         bindingContext[BindingContext.TYPE_ALIAS, psi]
     }
 
@@ -40,13 +41,13 @@ internal class KtFe10PsiTypeAliasSymbol(
         get() = withValidityAssertion { psi.nameAsSafeName }
 
     override val typeParameters: List<KtTypeParameterSymbol>
-        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisSession) } }
+        get() = withValidityAssertion { psi.typeParameters.map { KtFe10PsiTypeParameterSymbol(it, analysisContext) } }
 
     override val visibility: Visibility
         get() = withValidityAssertion { psi.ktVisibility ?: descriptor?.ktVisibility ?: Visibilities.Public }
 
     override val expandedType: KtType
-        get() = withValidityAssertion { descriptor?.expandedType?.toKtType(analysisSession) ?: createErrorType() }
+        get() = withValidityAssertion { descriptor?.expandedType?.toKtType(analysisContext) ?: createErrorType() }
 
     override val classIdIfNonLocal: ClassId?
         get() = withValidityAssertion { psi.getClassId() }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt
index c85b8581636..93b66d8fe13 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiTypeParameterSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.pointers.KtFe10NeverRestoringSymbolPointer
@@ -24,10 +25,10 @@ import org.jetbrains.kotlin.types.Variance
 
 internal class KtFe10PsiTypeParameterSymbol(
     override val psi: KtTypeParameter,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtTypeParameterSymbol(), KtFe10PsiSymbol<KtTypeParameter, TypeParameterDescriptor> {
     override val descriptor: TypeParameterDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi)
+        val bindingContext = analysisContext.analyze(psi)
         bindingContext[BindingContext.TYPE_PARAMETER, psi]
     }
 
@@ -35,7 +36,7 @@ internal class KtFe10PsiTypeParameterSymbol(
         get() = withValidityAssertion { psi.variance }
 
     override val upperBounds: List<KtType>
-        get() = withValidityAssertion { descriptor?.upperBounds?.map { it.toKtType(analysisSession) } ?: emptyList() }
+        get() = withValidityAssertion { descriptor?.upperBounds?.map { it.toKtType(analysisContext) } ?: emptyList() }
 
     override val isReified: Boolean
         get() = withValidityAssertion { psi.hasModifier(KtTokens.REIFIED_KEYWORD) }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt
index deedbe8ef4e..a85b1159e2d 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/KtFe10PsiValueParameterSymbol.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisFacade.AnalysisMode
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtTypeAndAnnotations
@@ -25,10 +26,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 
 internal class KtFe10PsiValueParameterSymbol(
     override val psi: KtParameter,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtValueParameterSymbol(), KtFe10PsiSymbol<KtParameter, VariableDescriptor> {
     override val descriptor: VariableDescriptor? by cached {
-        val bindingContext = analysisSession.analyze(psi, AnalysisMode.PARTIAL)
+        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
         bindingContext[BindingContext.VALUE_PARAMETER, psi]
     }
 
@@ -41,7 +42,7 @@ internal class KtFe10PsiValueParameterSymbol(
     override val annotatedType: KtTypeAndAnnotations
         get() = withValidityAssertion {
             val type = (descriptor as? ValueParameterDescriptor)?.varargElementType ?: descriptor?.type
-            return type?.toKtTypeAndAnnotations(analysisSession) ?: createErrorTypeAndAnnotations()
+            return type?.toKtTypeAndAnnotations(analysisContext) ?: createErrorTypeAndAnnotations()
         }
 
     override val name: Name
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt
index e1d7f344b85..dd860df0cf9 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/symbols/psiBased/base/KtFe10PsiSymbolUtils.kt
@@ -133,5 +133,5 @@ internal fun KtFe10Symbol.createErrorTypeAndAnnotations(): KtTypeAndAnnotations
 
 internal fun KtFe10Symbol.createErrorType(): KtType {
     val type = ErrorUtils.createErrorType("Type is unavailable for declaration $psi") as ErrorType
-    return KtFe10ClassErrorType(type, analysisSession)
+    return KtFe10ClassErrorType(type, analysisContext)
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt
index b27b96a69f7..ac32cf7e884 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10CapturedType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
@@ -16,7 +17,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.CapturedType
 
 internal class KtFe10CapturedType(
     override val type: CapturedType,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtCapturedType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt
index f3822758205..1b1378cf0cb 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10ClassErrorType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
@@ -17,7 +18,7 @@ import org.jetbrains.kotlin.types.ErrorType
 
 internal class KtFe10ClassErrorType(
     override val type: ErrorType,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtClassErrorType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt
index b30fb4970dd..85474fd17ca 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10DefinitelyNotNullType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
@@ -16,10 +17,10 @@ import org.jetbrains.kotlin.types.DefinitelyNotNullType
 
 internal class KtFe10DefinitelyNotNullType(
     override val type: DefinitelyNotNullType,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtDefinitelyNotNullType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
     override val original: KtType
-        get() = withValidityAssertion { type.original.toKtType(analysisSession) }
+        get() = withValidityAssertion { type.original.toKtType(analysisContext) }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt
index 13459e91c2f..53bd3c78649 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FlexibleType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
@@ -18,15 +19,15 @@ import org.jetbrains.kotlin.types.FlexibleType
 
 internal class KtFe10FlexibleType(
     override val type: FlexibleType,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFlexibleType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
     override val lowerBound: KtType
-        get() = withValidityAssertion { type.lowerBound.toKtType(analysisSession) }
+        get() = withValidityAssertion { type.lowerBound.toKtType(analysisContext) }
 
     override val upperBound: KtType
-        get() = withValidityAssertion { type.upperBound.toKtType(analysisSession) }
+        get() = withValidityAssertion { type.upperBound.toKtType(analysisContext) }
 
     override val nullability: KtTypeNullability
         get() = withValidityAssertion { type.ktNullability }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt
index 10797fbf8c3..8630d9b8ed9 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10FunctionalType.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
@@ -28,7 +29,7 @@ import org.jetbrains.kotlin.types.SimpleType
 internal class KtFe10FunctionalType(
     override val type: SimpleType,
     private val descriptor: FunctionClassDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtFunctionalType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
@@ -45,20 +46,20 @@ internal class KtFe10FunctionalType(
         get() = withValidityAssertion { type.getReceiverTypeFromFunctionType() != null }
 
     override val receiverType: KtType?
-        get() = withValidityAssertion { type.getReceiverTypeFromFunctionType()?.toKtType(analysisSession) }
+        get() = withValidityAssertion { type.getReceiverTypeFromFunctionType()?.toKtType(analysisContext) }
 
     override val parameterTypes: List<KtType>
-        get() = withValidityAssertion { type.getValueParameterTypesFromFunctionType().map { it.type.toKtType(analysisSession) } }
+        get() = withValidityAssertion { type.getValueParameterTypesFromFunctionType().map { it.type.toKtType(analysisContext) } }
 
     override val returnType: KtType
-        get() = withValidityAssertion { type.getReturnTypeFromFunctionType().toKtType(analysisSession) }
+        get() = withValidityAssertion { type.getReturnTypeFromFunctionType().toKtType(analysisContext) }
 
     override val classId: ClassId
         get() = ClassId(descriptor.functionKind.packageFqName, descriptor.functionKind.numberedClassName(descriptor.arity))
 
     override val classSymbol: KtClassLikeSymbol
-        get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisSession) }
+        get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisContext) }
 
     override val typeArguments: List<KtTypeArgument>
-        get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisSession) } }
+        get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisContext) } }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt
index be04e557039..17119fb670b 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10IntersectionType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
@@ -22,7 +23,7 @@ import org.jetbrains.kotlin.types.typeUtil.makeNullable
 internal class KtFe10IntersectionType(
     override val type: SimpleType,
     private val supertypes: Collection<KotlinType>,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtIntersectionType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
@@ -31,7 +32,7 @@ internal class KtFe10IntersectionType(
         val isNullable = type.isMarkedNullable
         for (supertype in supertypes) {
             val mappedSupertype = if (isNullable) supertype.makeNullable() else supertype
-            result += mappedSupertype.toKtType(analysisSession)
+            result += mappedSupertype.toKtType(analysisContext)
         }
         return@cached result
     }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt
index d4387c9b20c..f8a1eb812f0 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10NewCapturedType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
@@ -16,7 +17,7 @@ import org.jetbrains.kotlin.types.checker.NewCapturedType
 
 internal class KtFe10NewCapturedType(
     override val type: NewCapturedType,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtCapturedType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.kt
index b4e5d4939ac..5c99b570503 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10TypeParameterType.kt
@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
@@ -21,7 +22,7 @@ import org.jetbrains.kotlin.types.SimpleType
 internal class KtFe10TypeParameterType(
     override val type: SimpleType,
     private val parameter: TypeParameterDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtTypeParameterType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
@@ -32,5 +33,5 @@ internal class KtFe10TypeParameterType(
         get() = withValidityAssertion { type.ktNullability }
 
     override val symbol: KtTypeParameterSymbol
-        get() = withValidityAssertion { KtFe10DescTypeParameterSymbol(parameter, analysisSession) }
+        get() = withValidityAssertion { KtFe10DescTypeParameterSymbol(parameter, analysisContext) }
 }
\ No newline at end of file
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.kt
index 52208cfb618..fe8eea9660d 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/KtFe10UsualClassType.kt
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.analysis.api.descriptors.types
 
 import org.jetbrains.kotlin.analysis.api.KtTypeArgument
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktNullability
@@ -24,7 +25,7 @@ import org.jetbrains.kotlin.types.SimpleType
 internal class KtFe10UsualClassType(
     override val type: SimpleType,
     private val descriptor: ClassDescriptor,
-    override val analysisSession: KtFe10AnalysisSession
+    override val analysisContext: Fe10AnalysisContext
 ) : KtUsualClassType(), KtFe10Type {
     override fun asStringForDebugging(): String = withValidityAssertion { type.asStringForDebugging() }
 
@@ -32,10 +33,10 @@ internal class KtFe10UsualClassType(
         get() = withValidityAssertion { descriptor.maybeLocalClassId }
 
     override val classSymbol: KtClassLikeSymbol
-        get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisSession) }
+        get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisContext) }
 
     override val typeArguments: List<KtTypeArgument>
-        get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisSession) } }
+        get() = withValidityAssertion { type.arguments.map { it.toKtTypeArgument(analysisContext) } }
 
     override val nullability: KtTypeNullability
         get() = withValidityAssertion { type.ktNullability }
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt
index bac4dc91182..11a573e67b5 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/types/base/KtFe10Type.kt
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.types.base
 
 import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 import org.jetbrains.kotlin.analysis.api.components.KtTypeRendererOptions
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10TypeRenderer
 import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
 import org.jetbrains.kotlin.types.KotlinType
@@ -16,10 +16,10 @@ import org.jetbrains.kotlin.types.UnwrappedType
 interface KtFe10Type : ValidityTokenOwner {
     val type: UnwrappedType
 
-    val analysisSession: KtFe10AnalysisSession
+    val analysisContext: Fe10AnalysisContext
 
     override val token: ValidityToken
-        get() = analysisSession.token
+        get() = analysisContext.token
 }
 
 internal fun KotlinType.asStringForDebugging(): String {
diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt
index c6bf50f4d72..88360e58547 100644
--- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt
+++ b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/utils/KtFe10Renderer.kt
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors.utils
 
 import org.jetbrains.kotlin.analysis.api.components.KtDeclarationRendererOptions
 import org.jetbrains.kotlin.analysis.api.components.RendererModifier
-import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.Fe10AnalysisContext
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.classId
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.isExplicitOverride
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.ktVisibility
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 internal typealias KtFe10RendererConsumer = StringBuilder
 
 internal class KtFe10Renderer(
-    private val analysisSession: KtFe10AnalysisSession,
+    private val analysisContext: Fe10AnalysisContext,
     private val options: KtDeclarationRendererOptions,
     isDebugText: Boolean = false
 ) {
@@ -68,8 +68,8 @@ internal class KtFe10Renderer(
     private val typeRenderer = KtFe10TypeRenderer(options.typeRendererOptions, isDebugText)
 
     private val typeApproximator = TypeApproximator(
-        analysisSession.resolveSession.moduleDescriptor.builtIns,
-        analysisSession.resolveSession.languageVersionSettings
+        analysisContext.resolveSession.moduleDescriptor.builtIns,
+        analysisContext.resolveSession.languageVersionSettings
     )
 
     private var indentation = 0
@@ -96,7 +96,7 @@ internal class KtFe10Renderer(
         if (shouldApproximate) {
             val approximatedType = typeApproximator.approximateToSuperType(type.unwrap(), PublicApproximatorConfiguration)
                 ?: type.takeIf { it.constructor.declarationDescriptor?.name != SpecialNames.NO_NAME_PROVIDED }
-                ?: analysisSession.resolveSession.moduleDescriptor.builtIns.anyType
+                ?: analysisContext.resolveSession.moduleDescriptor.builtIns.anyType
 
             renderType(approximatedType, shouldApproximate = false)
             return
@@ -482,7 +482,7 @@ internal class KtFe10Renderer(
         body?.accept(object : KtTreeVisitorVoid() {
             override fun visitDeclaration(declaration: KtDeclaration) {
                 if (declaration is KtFunction || declaration is KtVariableDeclaration || declaration is KtClassOrObject) {
-                    val bindingContext = analysisSession.analyze(declaration)
+                    val bindingContext = analysisContext.analyze(declaration)
                     val childDescriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration]
                     if (childDescriptor != null) {
                         collectedChildren += childDescriptor