[Symbol LC] get rid of usage of analyzeWithSymbolAsContext for LC

analysis/symbol-light-classes/build.gradle.kts

@@ -33,4 +33,9 @@ projectTest(jUnitMode = JUnitMode.JUnit5) {
     useJUnitPlatform()
 }
 
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+    kotlinOptions.freeCompilerArgs += "-Xcontext-receivers"
+}
+
+
 testsJar()

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

@@ -13,6 +13,9 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParameters
 import org.jetbrains.kotlin.light.classes.symbol.elements.FirLightTypeParameter
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightTypeParameterListForSymbol(
     internal val owner: PsiTypeParameterListOwner,
     private val symbolWithTypeParameterList: KtSymbolWithTypeParameters,

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiClass
 import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.DecompiledLightClassesFactory
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
@@ -19,6 +20,7 @@ import org.jetbrains.kotlin.asJava.classes.KtFakeLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.light.classes.symbol.caches.SymbolLightClassFacadeCache
+import org.jetbrains.kotlin.light.classes.symbol.classes.analyseForLightClasses
 import org.jetbrains.kotlin.light.classes.symbol.classes.getOrCreateFirLightClass
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -129,12 +131,15 @@ class KotlinAsJavaFirSupport(private val project: Project) : KotlinAsJavaSupport
         TODO("Not implemented")
 
     private fun getFacadeClassesForFiles(facadeFqName: FqName, allFiles: Collection<KtFile>): Collection<PsiClass> {
+        if (allFiles.isEmpty()) return emptyList()
         val filesByModule = allFiles.groupBy { it.getKtModule(project) }
 
         val lightClassFacadeCache = project.getService(SymbolLightClassFacadeCache::class.java)
 
-        return filesByModule.values.mapNotNull { files ->
-            lightClassFacadeCache.getOrCreateSymbolLightFacade(files, facadeFqName)
+        return filesByModule.mapNotNull { (module, files) ->
+            analyseForLightClasses(module) {
+                lightClassFacadeCache.getOrCreateSymbolLightFacade(files, facadeFqName)
+            }
         }
     }
 }

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

@@ -5,13 +5,13 @@
 
 package org.jetbrains.kotlin.light.classes.symbol
 
-import com.intellij.openapi.project.Project
 import com.intellij.psi.CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION
 import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.annotations.Nullable
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.annotations.annotations
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
@@ -49,18 +49,17 @@ internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget:
     }
 }
 
+context(KtAnalysisSession)
 internal fun isHiddenByDeprecation(
-    project: Project,
     symbol: KtAnnotatedSymbol,
     annotationUseSiteTarget: AnnotationUseSiteTarget? = null
 ): Boolean {
-    return project.analyzeWithSymbolAsContext(symbol) {
-        symbol.getDeprecationStatus(annotationUseSiteTarget)?.deprecationLevel == DeprecationLevelValue.HIDDEN
-    }
+    return symbol.getDeprecationStatus(annotationUseSiteTarget)?.deprecationLevel == DeprecationLevelValue.HIDDEN
 }
 
-internal fun KtAnnotatedSymbol.isHiddenOrSynthetic(project: Project, annotationUseSiteTarget: AnnotationUseSiteTarget? = null) =
-    isHiddenByDeprecation(project, this, annotationUseSiteTarget) || hasJvmSyntheticAnnotation(annotationUseSiteTarget)
+context(KtAnalysisSession)
+internal fun KtAnnotatedSymbol.isHiddenOrSynthetic(annotationUseSiteTarget: AnnotationUseSiteTarget? = null) =
+    isHiddenByDeprecation(this, annotationUseSiteTarget) || hasJvmSyntheticAnnotation(annotationUseSiteTarget)
 
 internal fun KtAnnotatedSymbol.hasJvmFieldAnnotation(): Boolean =
     hasAnnotation(JVM_FIELD_ANNOTATION_CLASS_ID, null)

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.light.classes.symbol.caches
 
 import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.DecompiledLightClassesFactory
 import org.jetbrains.kotlin.analysis.decompiler.psi.file.KtClsFile
 import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
@@ -14,6 +15,7 @@ import org.jetbrains.kotlin.analysis.utils.collections.ConcurrentMapBasedCache
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.light.classes.symbol.FirLightClassForFacade
+import org.jetbrains.kotlin.light.classes.symbol.classes.analyseForLightClasses
 import org.jetbrains.kotlin.light.classes.symbol.decompiled.KtLightClassForDecompiledFacade
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -47,7 +49,9 @@ class SymbolLightClassFacadeCache(private val project: Project) {
         val firstFile = ktFiles.first()
         return when {
             ktFiles.none { it.isCompiled } ->
-                return FirLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles)
+                analyseForLightClasses(firstFile) {
+                    FirLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles)
+                }
             ktFiles.all { it.isCompiled } -> {
                 val file = ktFiles.firstOrNull { it.javaFileFacadeFqName == facadeClassFqName } as? KtClsFile
                     ?: error("Can't find the representative decompiled file for $facadeClassFqName")

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

@@ -15,7 +15,9 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
 import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 
+context(KtAnalysisSession)
 internal class FirLightAnnotationClassSymbol(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     manager: PsiManager
@@ -36,17 +38,12 @@ internal class FirLightAnnotationClassSymbol(
     override fun getOwnFields(): List<KtLightField> = _ownFields
 
     private val _ownMethods: List<KtLightMethod> by lazyPub {
-
         val result = mutableListOf<KtLightMethod>()
+        val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+            .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() }
+            .filterNot { it is KtConstructorSymbol }
 
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
-                .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() }
-                .filterNot { it is KtConstructorSymbol }
-
-            createMethods(visibleDeclarations, result)
-        }
-
+        createMethods(visibleDeclarations, result)
         result
     }
 

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

@@ -11,6 +11,7 @@ import com.intellij.psi.impl.PsiClassImplUtil
 import com.intellij.psi.search.SearchScope
 import com.intellij.psi.stubs.IStubElementType
 import com.intellij.psi.stubs.StubElement
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
@@ -24,6 +25,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
 import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
 
+context(KtAnalysisSession)
 internal class FirLightAnonymousClassForSymbol(
     private val anonymousObjectSymbol: KtAnonymousObjectSymbol,
     manager: PsiManager
@@ -51,16 +53,12 @@ internal class FirLightAnonymousClassForSymbol(
     override fun getOwnMethods(): List<PsiMethod> = _ownMethods
 
     private val _ownMethods: List<KtLightMethod> by lazyPub {
-
         val result = mutableListOf<KtLightMethod>()
 
-        analyzeWithSymbolAsContext(anonymousObjectSymbol) {
-            val declaredMemberScope = anonymousObjectSymbol.getDeclaredMemberScope()
+        val declaredMemberScope = anonymousObjectSymbol.getDeclaredMemberScope()
 
-            createMethods(declaredMemberScope.getCallableSymbols(), result)
-
-            createConstructors(declaredMemberScope.getConstructors(), result)
-        }
+        createMethods(declaredMemberScope.getCallableSymbols(), result)
+        createConstructors(declaredMemberScope.getConstructors(), result)
 
         result
     }
@@ -69,20 +67,18 @@ internal class FirLightAnonymousClassForSymbol(
         val result = mutableListOf<KtLightField>()
         val nameGenerator = FirLightField.FieldNameGenerator()
 
-        analyzeWithSymbolAsContext(anonymousObjectSymbol) {
-            anonymousObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
-                .filterIsInstance<KtPropertySymbol>()
-                .forEach { propertySymbol ->
-                    createField(
-                        propertySymbol,
-                        nameGenerator,
-                        isTopLevel = false,
-                        forceStatic = false,
-                        takePropertyVisibility = propertySymbol.hasJvmFieldAnnotation(),
-                        result
-                    )
-                }
-        }
+        anonymousObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+            .filterIsInstance<KtPropertySymbol>()
+            .forEach { propertySymbol ->
+                createField(
+                    propertySymbol,
+                    nameGenerator,
+                    isTopLevel = false,
+                    forceStatic = false,
+                    takePropertyVisibility = propertySymbol.hasJvmFieldAnnotation(),
+                    result
+                )
+            }
 
         result
     }

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

@@ -19,6 +19,7 @@ import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.PsiUtil
 import org.jetbrains.annotations.NonNls
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
 import org.jetbrains.kotlin.asJava.classes.*
@@ -26,6 +27,7 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.light.classes.symbol.classes.checkIsInheritor
 import javax.swing.Icon
 
+context(KtAnalysisSession)
 abstract class FirLightClassBase protected constructor(
     manager: PsiManager
 ) : LightElement(manager, KotlinLanguage.INSTANCE), PsiClass, KtExtensibleLightClass {

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

@@ -12,11 +12,12 @@ import com.intellij.psi.search.SearchScope
 import com.intellij.psi.stubs.IStubElementType
 import com.intellij.psi.stubs.StubElement
 import org.jetbrains.annotations.NonNls
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.asJava.classes.getOutermostClassOrObject
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
-import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.light.classes.symbol.classes.createInnerClasses
 import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods
@@ -31,6 +32,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.applyIf
 import org.jetbrains.kotlin.utils.addToStdlib.ifFalse
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
+context(KtAnalysisSession)
 internal abstract class FirLightClassForClassOrObjectSymbol(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     manager: PsiManager
@@ -90,22 +92,20 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
 
     protected fun addMethodsFromCompanionIfNeeded(result: MutableList<KtLightMethod>) {
         classOrObjectSymbol.companionObject?.run {
-            analyzeWithSymbolAsContext(this) {
-                val methods = getDeclaredMemberScope().getCallableSymbols()
-                    .filterIsInstance<KtFunctionSymbol>()
-                    .filter { it.hasJvmStaticAnnotation() }
-                createMethods(methods, result)
+            val methods = getDeclaredMemberScope().getCallableSymbols()
+                .filterIsInstance<KtFunctionSymbol>()
+                .filter { it.hasJvmStaticAnnotation() }
+            createMethods(methods, result)
 
-                val properties = getDeclaredMemberScope().getCallableSymbols()
-                    .filterIsInstance<KtPropertySymbol>()
-                properties.forEach { property ->
-                    createPropertyAccessors(
-                        result,
-                        property,
-                        isTopLevel = false,
-                        onlyJvmStatic = true
-                    )
-                }
+            val properties = getDeclaredMemberScope().getCallableSymbols()
+                .filterIsInstance<KtPropertySymbol>()
+            properties.forEach { property ->
+                createPropertyAccessors(
+                    result,
+                    property,
+                    isTopLevel = false,
+                    onlyJvmStatic = true
+                )
             }
         }
     }
@@ -125,24 +125,22 @@ internal abstract class FirLightClassForClassOrObjectSymbol(
 
     protected fun addFieldsFromCompanionIfNeeded(result: MutableList<KtLightField>) {
         classOrObjectSymbol.companionObject?.run {
-            analyzeWithSymbolAsContext(this) {
-                getDeclaredMemberScope().getCallableSymbols()
-                    .filterIsInstance<KtPropertySymbol>()
-                    .applyIf(isInterface) {
-                        filter { it.hasJvmFieldAnnotation() || it.isConst }
-                    }
-                    .mapTo(result) {
-                        FirLightFieldForPropertySymbol(
-                            propertySymbol = it,
-                            fieldName = it.name.asString(),
-                            containingClass = this@FirLightClassForClassOrObjectSymbol,
-                            lightMemberOrigin = null,
-                            isTopLevel = false,
-                            forceStatic = true,
-                            takePropertyVisibility = true
-                        )
-                    }
-            }
+            getDeclaredMemberScope().getCallableSymbols()
+                .filterIsInstance<KtPropertySymbol>()
+                .applyIf(isInterface) {
+                    filter { it.hasJvmFieldAnnotation() || it.isConst }
+                }
+                .mapTo(result) {
+                    FirLightFieldForPropertySymbol(
+                        propertySymbol = it,
+                        fieldName = it.name.asString(),
+                        containingClass = this@FirLightClassForClassOrObjectSymbol,
+                        lightMemberOrigin = null,
+                        isTopLevel = false,
+                        forceStatic = true,
+                        takePropertyVisibility = true
+                    )
+                }
         }
     }
 

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

@@ -7,17 +7,18 @@ package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
 import com.intellij.psi.impl.PsiClassImplUtil
-import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.asJava.classes.KotlinSuperTypeListBuilder
 import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.light.classes.symbol.classes.createConstructors
 import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtClassOrObject
-
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+context(KtAnalysisSession)
 internal class FirLightClassForEnumEntry(
     private val enumEntrySymbol: KtEnumEntrySymbol,
     private val enumConstant: FirLightFieldForEnumEntry,
@@ -82,10 +83,10 @@ internal class FirLightClassForEnumEntry(
     override fun isEnum(): Boolean = false
 
     private val _extendsList: PsiReferenceList? by lazyPub {
-        val mappedType = analyzeWithSymbolAsContext(enumEntrySymbol) {
+        val mappedType =
             enumEntrySymbol.returnType.asPsiType(this@FirLightClassForEnumEntry, KtTypeMappingMode.SUPER_TYPE) as? PsiClassType
                 ?: return@lazyPub null
-        }
+
 
         KotlinSuperTypeListBuilder(
             kotlinOrigin = enumClass.kotlinOrigin?.getSuperTypeList(),
@@ -126,13 +127,10 @@ internal class FirLightClassForEnumEntry(
     override fun getOwnMethods(): MutableList<KtLightMethod> {
         val result = mutableListOf<KtLightMethod>()
 
-        analyzeWithSymbolAsContext(enumEntrySymbol) {
-            val declaredMemberScope = enumEntrySymbol.getDeclaredMemberScope()
+        val declaredMemberScope = enumEntrySymbol.getDeclaredMemberScope()
 
-            createMethods(declaredMemberScope.getCallableSymbols(), result)
-
-            createConstructors(declaredMemberScope.getConstructors(), result)
-        }
+        createMethods(declaredMemberScope.getCallableSymbols(), result)
+        createConstructors(declaredMemberScope.getConstructors(), result)
 
         return result
     }

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

@@ -10,6 +10,7 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.light.LightEmptyImplementsList
 import com.intellij.psi.impl.light.LightModifierList
 import org.jetbrains.annotations.NonNls
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
@@ -32,6 +33,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 
+context(KtAnalysisSession)
 class FirLightClassForFacade(
     manager: PsiManager,
     override val facadeClassFqName: FqName,
@@ -85,15 +87,13 @@ class FirLightClassForFacade(
 
         val methodsAndProperties = sequence<KtCallableSymbol> {
             for (fileSymbol in fileSymbols) {
-                analyzeWithSymbolAsContext(fileSymbol) {
-                    for (callableSymbol in fileSymbol.getFileScope().getCallableSymbols()) {
-                        if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtKotlinPropertySymbol) continue
-                        if (callableSymbol !is KtSymbolWithVisibility) continue
-                        if ((callableSymbol as? KtAnnotatedSymbol)?.hasInlineOnlyAnnotation() == true) continue
-                        val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE
-                        if (isPrivate && multiFileClass) continue
-                        yield(callableSymbol)
-                    }
+                for (callableSymbol in fileSymbol.getFileScope().getCallableSymbols()) {
+                    if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtKotlinPropertySymbol) continue
+                    if (callableSymbol !is KtSymbolWithVisibility) continue
+                    if ((callableSymbol as? KtAnnotatedSymbol)?.hasInlineOnlyAnnotation() == true) continue
+                    val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE
+                    if (isPrivate && multiFileClass) continue
+                    yield(callableSymbol)
                 }
             }
         }
@@ -146,9 +146,7 @@ class FirLightClassForFacade(
         val result = mutableListOf<KtLightField>()
         val nameGenerator = FirLightField.FieldNameGenerator()
         for (fileSymbol in fileSymbols) {
-            analyzeWithSymbolAsContext(fileSymbol) {
-                loadFieldsFromFile(fileSymbol.getFileScope(), nameGenerator, result)
-            }
+            loadFieldsFromFile(fileSymbol.getFileScope(), nameGenerator, result)
         }
         result
     }

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

@@ -11,6 +11,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.load.java.JvmAbi
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightClassForInterfaceDefaultImpls(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     private val containingClass: FirLightClassBase,

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

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS
 import org.jetbrains.kotlin.util.OperatorNameConventions.TO_STRING
 import org.jetbrains.kotlin.utils.addToStdlib.applyIf
 
+context(KtAnalysisSession)
 internal open class FirLightClassForSymbol(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     manager: PsiManager
@@ -72,32 +73,31 @@ internal open class FirLightClassForSymbol(
 
         val result = mutableListOf<KtLightMethod>()
 
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope()
+        val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope()
 
-            val visibleDeclarations = declaredMemberScope.getCallableSymbols().applyIf(isEnum) {
-                filterNot { function ->
-                    function is KtFunctionSymbol &&
-                            (function.name == ENUM_VALUES || function.name == ENUM_VALUE_OF)
-                }
-            }.applyIf(classOrObjectSymbol.isObject) {
-                filterNot {
-                    it is KtKotlinPropertySymbol && it.isConst
-                }
-            }.applyIf(classOrObjectSymbol.isData) {
-                // Technically, synthetic members of `data` class, such as `componentN` or `copy`, are visible.
-                // They're just needed to be added later (to be in a backward-compatible order of members).
-                filterNot { function ->
-                    function is KtFunctionSymbol && function.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED
-                }
+        val visibleDeclarations = declaredMemberScope.getCallableSymbols().applyIf(isEnum) {
+            filterNot { function ->
+                function is KtFunctionSymbol &&
+                        (function.name == ENUM_VALUES || function.name == ENUM_VALUE_OF)
+            }
+        }.applyIf(classOrObjectSymbol.isObject) {
+            filterNot {
+                it is KtKotlinPropertySymbol && it.isConst
+            }
+        }.applyIf(classOrObjectSymbol.isData) {
+            // Technically, synthetic members of `data` class, such as `componentN` or `copy`, are visible.
+            // They're just needed to be added later (to be in a backward-compatible order of members).
+            filterNot { function ->
+                function is KtFunctionSymbol && function.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED
             }
-
-            val suppressStatic = isCompanionObject
-            createMethods(visibleDeclarations, result, suppressStatic = suppressStatic)
-
-            createConstructors(declaredMemberScope.getConstructors(), result)
         }
 
+        val suppressStatic = isCompanionObject
+        createMethods(visibleDeclarations, result, suppressStatic = suppressStatic)
+
+        createConstructors(declaredMemberScope.getConstructors(), result)
+
+
         addMethodsFromCompanionIfNeeded(result)
 
         addMethodsFromDataClass(result)
@@ -114,17 +114,13 @@ internal open class FirLightClassForSymbol(
             val lightMemberOrigin = LightMemberOriginForDeclaration(this.kotlinOrigin!!, JvmDeclarationOriginKind.OTHER)
             result.add(
                 FirLightSimpleMethodForSymbol(
-                    functionSymbol = ktFunctionSymbol,
-                    lightMemberOrigin = lightMemberOrigin,
-                    containingClass = this,
-                    isTopLevel = false,
-                    methodIndex = METHOD_INDEX_BASE,
+                    ktFunctionSymbol, lightMemberOrigin, this, METHOD_INDEX_BASE, false,
                     suppressStatic = false
                 )
             )
         }
 
-        fun KtAnalysisSession.actuallyComesFromAny(functionSymbol: KtFunctionSymbol): Boolean {
+        fun actuallyComesFromAny(functionSymbol: KtFunctionSymbol): Boolean {
             require(functionSymbol.name.isFromAny) {
                 "This function's name should one of three Any's function names, but it was ${functionSymbol.name}"
             }
@@ -136,56 +132,52 @@ internal open class FirLightClassForSymbol(
 
         // NB: componentN and copy are added during RAW FIR, but synthetic members from `Any` are not.
         // That's why we use declared scope for 'component*' and 'copy', and member scope for 'equals/hashCode/toString'
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            val componentAndCopyFunctions = classOrObjectSymbol.getDeclaredMemberScope()
-                .getCallableSymbols { name -> DataClassResolver.isCopy(name) || DataClassResolver.isComponentLike(name) }
-                .filter { it.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED }
-                .filterIsInstance<KtFunctionSymbol>()
+        val componentAndCopyFunctions = classOrObjectSymbol.getDeclaredMemberScope()
+            .getCallableSymbols { name -> DataClassResolver.isCopy(name) || DataClassResolver.isComponentLike(name) }
+            .filter { it.origin == KtSymbolOrigin.SOURCE_MEMBER_GENERATED }
+            .filterIsInstance<KtFunctionSymbol>()
 
-            createMethods(componentAndCopyFunctions, result)
+        createMethods(componentAndCopyFunctions, result)
 
-            // Compiler will generate 'equals/hashCode/toString' for data class if they are not final.
-            // We want to mimic that.
-            val nonFinalFunctionsFromAny = classOrObjectSymbol.getMemberScope()
-                .getCallableSymbols { name -> name.isFromAny }
-                .filterIsInstance<KtFunctionSymbol>()
-                .filterNot { it.modality == Modality.FINAL }
-                .filter { actuallyComesFromAny(it) }
+        // Compiler will generate 'equals/hashCode/toString' for data class if they are not final.
+        // We want to mimic that.
+        val nonFinalFunctionsFromAny = classOrObjectSymbol.getMemberScope()
+            .getCallableSymbols { name -> name.isFromAny }
+            .filterIsInstance<KtFunctionSymbol>()
+            .filterNot { it.modality == Modality.FINAL }
+            .filter { actuallyComesFromAny(it) }
 
-            val functionsFromAnyByName = nonFinalFunctionsFromAny.associateBy { it.name }
+        val functionsFromAnyByName = nonFinalFunctionsFromAny.associateBy { it.name }
 
-            // NB: functions from `Any` are not in an alphabetic order.
-            functionsFromAnyByName[TO_STRING]?.let { createMethodFromAny(it) }
-            functionsFromAnyByName[HASHCODE_NAME]?.let { createMethodFromAny(it) }
-            functionsFromAnyByName[EQUALS]?.let { createMethodFromAny(it) }
-        }
+        // NB: functions from `Any` are not in an alphabetic order.
+        functionsFromAnyByName[TO_STRING]?.let { createMethodFromAny(it) }
+        functionsFromAnyByName[HASHCODE_NAME]?.let { createMethodFromAny(it) }
+        functionsFromAnyByName[EQUALS]?.let { createMethodFromAny(it) }
     }
 
     private val Name.isFromAny: Boolean
         get() = this == EQUALS || this == HASHCODE_NAME || this == TO_STRING
 
     private fun addDelegatesToInterfaceMethods(result: MutableList<KtLightMethod>) {
-
         fun createDelegateMethod(ktFunctionSymbol: KtFunctionSymbol) {
             val kotlinOrigin = ktFunctionSymbol.psi as? KtDeclaration ?: kotlinOrigin!!
             val lightMemberOrigin = LightMemberOriginForDeclaration(kotlinOrigin, JvmDeclarationOriginKind.DELEGATION)
             result.add(
                 FirLightSimpleMethodForSymbol(
-                    functionSymbol = ktFunctionSymbol,
-                    lightMemberOrigin = lightMemberOrigin,
-                    containingClass = this,
-                    isTopLevel = false,
-                    methodIndex = METHOD_INDEX_FOR_NON_ORIGIN_METHOD,
+                    ktFunctionSymbol,
+                    lightMemberOrigin,
+                    this,
+                    METHOD_INDEX_FOR_NON_ORIGIN_METHOD,
+                    false,
+                    argumentsSkipMask = null,
                     suppressStatic = false
                 )
             )
         }
 
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            classOrObjectSymbol.getDelegatedMemberScope().getCallableSymbols().forEach { functionSymbol ->
-                if (functionSymbol is KtFunctionSymbol) {
-                    createDelegateMethod(functionSymbol)
-                }
+        classOrObjectSymbol.getDelegatedMemberScope().getCallableSymbols().forEach { functionSymbol ->
+            if (functionSymbol is KtFunctionSymbol) {
+                createDelegateMethod(functionSymbol)
             }
         }
     }
@@ -211,41 +203,39 @@ internal open class FirLightClassForSymbol(
     }
 
     private fun addPropertyBackingFields(result: MutableList<KtLightField>) {
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            val propertySymbols = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
-                .filterIsInstance<KtPropertySymbol>()
-                .applyIf(isCompanionObject) {
-                    // All fields for companion object of classes are generated to the containing class
-                    // For interfaces, only @JvmField-annotated properties are generated to the containing class
-                    // Probably, the same should work for const vals but it doesn't at the moment (see KT-28294)
-                    filter { containingClass?.isInterface == true && !it.hasJvmFieldAnnotation() }
-                }
-            val propertyGroups = propertySymbols.groupBy { it.isFromPrimaryConstructor }
-
-            val nameGenerator = FirLightField.FieldNameGenerator()
-
-            fun addPropertyBackingField(propertySymbol: KtPropertySymbol) {
-                val isJvmField = propertySymbol.hasJvmFieldAnnotation()
-                val isLateInit = (propertySymbol as? KtKotlinPropertySymbol)?.isLateInit == true
-
-                val forceStatic = classOrObjectSymbol.isObject
-                val takePropertyVisibility = !isCompanionObject && (isLateInit || isJvmField)
-
-                createField(
-                    declaration = propertySymbol,
-                    nameGenerator = nameGenerator,
-                    isTopLevel = false,
-                    forceStatic = forceStatic,
-                    takePropertyVisibility = takePropertyVisibility,
-                    result = result
-                )
+        val propertySymbols = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+            .filterIsInstance<KtPropertySymbol>()
+            .applyIf(isCompanionObject) {
+                // All fields for companion object of classes are generated to the containing class
+                // For interfaces, only @JvmField-annotated properties are generated to the containing class
+                // Probably, the same should work for const vals but it doesn't at the moment (see KT-28294)
+                filter { containingClass?.isInterface == true && !it.hasJvmFieldAnnotation() }
             }
+        val propertyGroups = propertySymbols.groupBy { it.isFromPrimaryConstructor }
 
-            // First, properties from parameters
-            propertyGroups[true]?.forEach(::addPropertyBackingField)
-            // Then, regular member properties
-            propertyGroups[false]?.forEach(::addPropertyBackingField)
+        val nameGenerator = FirLightField.FieldNameGenerator()
+
+        fun addPropertyBackingField(propertySymbol: KtPropertySymbol) {
+            val isJvmField = propertySymbol.hasJvmFieldAnnotation()
+            val isLateInit = (propertySymbol as? KtKotlinPropertySymbol)?.isLateInit == true
+
+            val forceStatic = classOrObjectSymbol.isObject
+            val takePropertyVisibility = !isCompanionObject && (isLateInit || isJvmField)
+
+            createField(
+                declaration = propertySymbol,
+                nameGenerator = nameGenerator,
+                isTopLevel = false,
+                forceStatic = forceStatic,
+                takePropertyVisibility = takePropertyVisibility,
+                result = result
+            )
         }
+
+        // First, properties from parameters
+        propertyGroups[true]?.forEach(::addPropertyBackingField)
+        // Then, regular member properties
+        propertyGroups[false]?.forEach(::addPropertyBackingField)
     }
 
     private fun addInstanceFieldIfNeeded(result: MutableList<KtLightField>) {
@@ -262,12 +252,10 @@ internal open class FirLightClassForSymbol(
     }
 
     private fun addFieldsForEnumEntries(result: MutableList<KtLightField>) {
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            if (isEnum) {
-                classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
-                    .filterIsInstance<KtEnumEntrySymbol>()
-                    .mapTo(result) { FirLightFieldForEnumEntry(it, this@FirLightClassForSymbol, null) }
-            }
+        if (isEnum) {
+            classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+                .filterIsInstance<KtEnumEntrySymbol>()
+                .mapTo(result) { FirLightFieldForEnumEntry(it, this@FirLightClassForSymbol, null) }
         }
     }
 

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

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
@@ -17,6 +18,7 @@ import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods
 import org.jetbrains.kotlin.light.classes.symbol.classes.createPropertyAccessors
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue
 
+context(KtAnalysisSession)
 internal class FirLightInlineClass(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     manager: PsiManager
@@ -29,32 +31,31 @@ internal class FirLightInlineClass(
     private val _ownMethods: List<KtLightMethod> by lazyPub {
         val result = mutableListOf<KtLightMethod>()
 
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope()
-            val applicableDeclarations = declaredMemberScope.getCallableSymbols()
-                .filter {
-                    (it as? KtPropertySymbol)?.isOverride == true || (it as? KtFunctionSymbol)?.isOverride == true
-                }
-                .filterNot {
-                    it.deprecationStatus?.deprecationLevel == DeprecationLevelValue.HIDDEN
-                }
+        val declaredMemberScope = classOrObjectSymbol.getDeclaredMemberScope()
+        val applicableDeclarations = declaredMemberScope.getCallableSymbols()
+            .filter {
+                (it as? KtPropertySymbol)?.isOverride == true || (it as? KtFunctionSymbol)?.isOverride == true
+            }
+            .filterNot {
+                it.deprecationStatus?.deprecationLevel == DeprecationLevelValue.HIDDEN
+            }
 
-            createMethods(applicableDeclarations, result, suppressStatic = false)
+        createMethods(applicableDeclarations, result, suppressStatic = false)
 
-            val inlineClassParameterSymbol =
-                declaredMemberScope.getConstructors().singleOrNull { it.isPrimary }?.valueParameters?.singleOrNull()
-            if (inlineClassParameterSymbol != null) {
-                val propertySymbol = declaredMemberScope.getCallableSymbols { it == inlineClassParameterSymbol.name }
-                    .singleOrNull { it is KtPropertySymbol && it.isFromPrimaryConstructor } as? KtPropertySymbol
-                if (propertySymbol != null) {
-                    // (inline or) value class primary constructor must have only final read-only (val) property parameter
-                    // Even though the property parameter is mutable (for some reasons, e.g., testing or not checked yet),
-                    // we can enforce immutability here.
-                    createPropertyAccessors(result, propertySymbol, isTopLevel = false, isMutable = false)
-                }
+        val inlineClassParameterSymbol =
+            declaredMemberScope.getConstructors().singleOrNull { it.isPrimary }?.valueParameters?.singleOrNull()
+        if (inlineClassParameterSymbol != null) {
+            val propertySymbol = declaredMemberScope.getCallableSymbols { it == inlineClassParameterSymbol.name }
+                .singleOrNull { it is KtPropertySymbol && it.isFromPrimaryConstructor } as? KtPropertySymbol
+            if (propertySymbol != null) {
+                // (inline or) value class primary constructor must have only final read-only (val) property parameter
+                // Even though the property parameter is mutable (for some reasons, e.g., testing or not checked yet),
+                // we can enforce immutability here.
+                createPropertyAccessors(result, propertySymbol, isTopLevel = false, isMutable = false)
             }
         }
 
+
         result
     }
 

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

@@ -8,17 +8,19 @@ package org.jetbrains.kotlin.light.classes.symbol
 import com.intellij.psi.PsiManager
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.PsiReferenceList
-import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.asJava.elements.KtLightField
-import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
+import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.asJava.elements.KtLightField
+import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.light.classes.symbol.classes.createInheritanceList
 import org.jetbrains.kotlin.light.classes.symbol.classes.createMethods
 
+context(KtAnalysisSession)
 internal open class FirLightInterfaceClassSymbol(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     manager: PsiManager
@@ -38,16 +40,12 @@ internal open class FirLightInterfaceClassSymbol(
     override fun getOwnFields(): List<KtLightField> = _ownFields
 
     private val _ownMethods: List<KtLightMethod> by lazyPub {
-
         val result = mutableListOf<KtLightMethod>()
 
-        analyzeWithSymbolAsContext(classOrObjectSymbol) {
-            val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
-                .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() }
-
-            createMethods(visibleDeclarations, result)
-        }
+        val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
+            .filterNot { it is KtFunctionSymbol && it.visibility.isPrivateOrPrivateToThis() }
 
+        createMethods(visibleDeclarations, result)
         addMethodsFromCompanionIfNeeded(result)
 
         result

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

@@ -5,12 +5,17 @@
 
 package org.jetbrains.kotlin.light.classes.symbol
 
-import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.classes.lazyPub
+import com.intellij.psi.PsiManager
+import com.intellij.psi.PsiModifier
+import com.intellij.psi.PsiModifierList
+import com.intellij.psi.PsiReferenceList
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassKind
 import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
+import org.jetbrains.kotlin.asJava.classes.lazyPub
 
+context(KtAnalysisSession)
 internal abstract class FirLightInterfaceOrAnnotationClassSymbol(
     private val classOrObjectSymbol: KtNamedClassOrObjectSymbol,
     manager: PsiManager

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

@@ -14,6 +14,9 @@ import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 
 //TODO Make fake class symbol based
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.light.classes.symbol.classes.analyseForLightClasses
+
 class KtFirBasedFakeLightClass(kotlinOrigin: KtClassOrObject) :
     KtFakeLightClass(kotlinOrigin) {
 
@@ -30,6 +33,8 @@ class KtFirBasedFakeLightClass(kotlinOrigin: KtClassOrObject) :
         LightClassInheritanceHelper.getService(project).isInheritor(this, baseClass, checkDeep).ifSure { return it }
 
         val baseClassOrigin = (baseClass as? KtLightClass)?.kotlinOrigin ?: return false
-        return kotlinOrigin.checkIsInheritor(baseClassOrigin, checkDeep)
+        return analyseForLightClasses(baseClassOrigin) {
+            kotlinOrigin.checkIsInheritor(baseClassOrigin, checkDeep)
+        }
     }
 }

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

@@ -8,7 +8,11 @@ package org.jetbrains.kotlin.light.classes.symbol.classes
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.analysis.api.lifetime.KtAlwaysAccessibleLifetimeTokenFactory
+import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.psi.KtElement
 
 internal inline fun <R> analyseForLightClasses(context: KtElement, action: KtAnalysisSession.() -> R): R =
-    analyze(context, KtAlwaysAccessibleLifetimeTokenFactory, action)
+    analyze(context, KtAlwaysAccessibleLifetimeTokenFactory, action)
+
+internal inline fun <R> analyseForLightClasses(useSiteKtModule: KtModule, crossinline action: KtAnalysisSession.() -> R): R =
+    analyze(useSiteKtModule, KtAlwaysAccessibleLifetimeTokenFactory, action)

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

@@ -11,16 +11,17 @@ import com.intellij.psi.PsiReferenceList
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
-import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithTypeParameters
 import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThis
-import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 import org.jetbrains.kotlin.analysis.api.types.KtNonErrorClassType
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModuleOfTypeSafe
+import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
 import org.jetbrains.kotlin.asJava.builder.LightMemberOriginForDeclaration
 import org.jetbrains.kotlin.asJava.classes.*
 import org.jetbrains.kotlin.asJava.elements.KtLightField
@@ -71,7 +72,9 @@ internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLight
     }
 
     return when {
-        classOrObject is KtEnumEntry -> lightClassForEnumEntry(classOrObject)
+        classOrObject is KtEnumEntry ->  analyseForLightClasses(classOrObject) {
+            lightClassForEnumEntry(classOrObject)
+        }
         classOrObject.hasModifier(INLINE_KEYWORD) -> {
             analyseForLightClasses(classOrObject) {
                 classOrObject.getNamedClassOrObjectSymbol()?.let { FirLightInlineClass(it, classOrObject.manager) }
@@ -85,7 +88,9 @@ internal fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLight
     }
 }
 
-internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): FirLightClassBase = when (this) {
+
+context(KtAnalysisSession)
+        internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager): FirLightClassBase = when (this) {
     is KtAnonymousObjectSymbol -> FirLightAnonymousClassForSymbol(this, manager)
     is KtNamedClassOrObjectSymbol -> when (classKind) {
         KtClassKind.INTERFACE -> FirLightInterfaceClassSymbol(this, manager)
@@ -94,7 +99,8 @@ internal fun KtClassOrObjectSymbol.createLightClassNoCache(manager: PsiManager):
     }
 }
 
-private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? {
+context(KtAnalysisSession)
+        private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? {
     if (ktEnumEntry.body == null) return null
 
     val firClass = ktEnumEntry
@@ -109,7 +115,8 @@ private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? {
     return (targetField as? FirLightFieldForEnumEntry)?.initializingClass as? KtLightClass
 }
 
-internal fun FirLightClassBase.createConstructors(
+context(KtAnalysisSession)
+        internal fun FirLightClassBase.createConstructors(
     declarations: Sequence<KtConstructorSymbol>,
     result: MutableList<KtLightMethod>
 ) {
@@ -119,7 +126,7 @@ internal fun FirLightClassBase.createConstructors(
         return
     }
     for (constructor in constructors) {
-        if (constructor.isHiddenOrSynthetic(project)) continue
+        if (constructor.isHiddenOrSynthetic()) continue
         result.add(
             FirLightConstructorForSymbol(
                 constructorSymbol = constructor,
@@ -137,7 +144,8 @@ internal fun FirLightClassBase.createConstructors(
     }
 }
 
-private fun FirLightClassBase.shouldGenerateNoArgOverload(
+context(KtAnalysisSession)
+        private fun FirLightClassBase.shouldGenerateNoArgOverload(
     primaryConstructor: KtConstructorSymbol,
     constructors: Iterable<KtConstructorSymbol>,
 ): Boolean {
@@ -151,7 +159,8 @@ private fun FirLightClassBase.shouldGenerateNoArgOverload(
             !primaryConstructor.hasJvmOverloadsAnnotation()
 }
 
-private fun FirLightClassBase.defaultConstructor(): KtLightMethod {
+context(KtAnalysisSession)
+        private fun FirLightClassBase.defaultConstructor(): KtLightMethod {
     val classOrObject = kotlinOrigin
     val visibility = when {
         classOrObject is KtObjectDeclaration || classOrObject?.hasModifier(SEALED_KEYWORD) == true || isEnum -> PsiModifier.PRIVATE
@@ -161,7 +170,8 @@ private fun FirLightClassBase.defaultConstructor(): KtLightMethod {
     return noArgConstructor(visibility, METHOD_INDEX_FOR_DEFAULT_CTOR)
 }
 
-private fun FirLightClassBase.noArgConstructor(
+context(KtAnalysisSession)
+        private fun FirLightClassBase.noArgConstructor(
     visibility: String,
     methodIndex: Int,
 ): KtLightMethod {
@@ -177,11 +187,12 @@ private fun FirLightClassBase.noArgConstructor(
     )
 }
 
-internal fun FirLightClassBase.createMethods(
+context(KtAnalysisSession)
+        internal fun FirLightClassBase.createMethods(
     declarations: Sequence<KtCallableSymbol>,
     result: MutableList<KtLightMethod>,
     isTopLevel: Boolean = false,
-    suppressStatic : Boolean = false
+    suppressStatic: Boolean = false
 ) {
     val declarationGroups = declarations.groupBy { it is KtPropertySymbol && it.isFromPrimaryConstructor }
 
@@ -190,7 +201,7 @@ internal fun FirLightClassBase.createMethods(
             is KtFunctionSymbol -> {
                 // TODO: check if it has expect modifier
                 if (declaration.hasReifiedParameters ||
-                    declaration.isHiddenOrSynthetic(project)
+                    declaration.isHiddenOrSynthetic()
                 ) return
 
                 var methodIndex = METHOD_INDEX_BASE
@@ -216,12 +227,7 @@ internal fun FirLightClassBase.createMethods(
 
                         result.add(
                             FirLightSimpleMethodForSymbol(
-                                functionSymbol = declaration,
-                                lightMemberOrigin = null,
-                                containingClass = this@createMethods,
-                                isTopLevel = isTopLevel,
-                                methodIndex = methodIndex++,
-                                argumentsSkipMask = skipMask.copy()
+                                declaration, null, this@createMethods, methodIndex++, isTopLevel, skipMask.copy()
                             )
                         )
                     }
@@ -234,7 +240,7 @@ internal fun FirLightClassBase.createMethods(
                 suppressStatic = suppressStatic
             )
             is KtConstructorSymbol -> error("Constructors should be handled separately and not passed to this function")
-            else -> { }
+            else -> {}
         }
     }
 
@@ -248,7 +254,8 @@ internal fun FirLightClassBase.createMethods(
     }
 }
 
-internal fun FirLightClassBase.createPropertyAccessors(
+context(KtAnalysisSession)
+        internal fun FirLightClassBase.createPropertyAccessors(
     result: MutableList<KtLightMethod>,
     declaration: KtPropertySymbol,
     isTopLevel: Boolean,
@@ -269,8 +276,8 @@ internal fun FirLightClassBase.createPropertyAccessors(
         if (onlyJvmStatic && !hasJvmStaticAnnotation(siteTarget) && !declaration.hasJvmStaticAnnotation()) return false
         if (declaration.hasReifiedParameters) return false
         if (!hasBody && visibility.isPrivateOrPrivateToThis()) return false
-        if (declaration.isHiddenOrSynthetic(project, siteTarget)) return false
-        if (isHiddenOrSynthetic(project)) return false
+        if (declaration.isHiddenOrSynthetic(siteTarget)) return false
+        if (isHiddenOrSynthetic()) return false
         return true
     }
 
@@ -326,7 +333,8 @@ internal fun FirLightClassBase.createPropertyAccessors(
     }
 }
 
-internal fun FirLightClassBase.createField(
+context(KtAnalysisSession)
+        internal fun FirLightClassBase.createField(
     declaration: KtPropertySymbol,
     nameGenerator: FirLightField.FieldNameGenerator,
     isTopLevel: Boolean,
@@ -339,7 +347,7 @@ internal fun FirLightClassBase.createField(
         is KtSyntheticJavaPropertySymbol -> true
         is KtKotlinPropertySymbol -> when {
             property.modality == Modality.ABSTRACT -> false
-            property.isHiddenOrSynthetic(project) -> false
+            property.isHiddenOrSynthetic() -> false
             property.isLateInit -> true
             property.isDelegatedProperty -> true
             property.isFromPrimaryConstructor -> true
@@ -369,7 +377,8 @@ internal fun FirLightClassBase.createField(
     )
 }
 
-internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {
+context(KtAnalysisSession)
+        internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List<KtType>): PsiReferenceList {
 
     val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST
 
@@ -400,16 +409,15 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su
         .filter { it.needToAddTypeIntoList() }
         .mapNotNull { type ->
             if (type !is KtNonErrorClassType) return@mapNotNull null
-            analyzeWithSymbolAsContext(type.classSymbol) {
-                mapSuperType(type, this@createInheritanceList, kotlinCollectionAsIs = true)
-            }
+            mapSuperType(type, this@createInheritanceList, kotlinCollectionAsIs = true)
         }
         .forEach { listBuilder.addReference(it) }
 
     return listBuilder
 }
 
-internal fun KtSymbolWithMembers.createInnerClasses(
+context(KtAnalysisSession)
+        internal fun KtSymbolWithMembers.createInnerClasses(
     manager: PsiManager,
     containingClass: FirLightClassBase,
     classOrObject: KtClassOrObject?
@@ -420,12 +428,11 @@ internal fun KtSymbolWithMembers.createInnerClasses(
     // inner classes with null names can't be searched for and can't be used from java anyway
     // we can't prohibit creating light classes with null names either since they can contain members
 
-    manager.project.analyzeWithSymbolAsContext(this) {
-        getDeclaredMemberScope().getClassifierSymbols().filterIsInstance<KtNamedClassOrObjectSymbol>().mapTo(result) {
-            it.createLightClassNoCache(manager)
-        }
+    getDeclaredMemberScope().getClassifierSymbols().filterIsInstance<KtNamedClassOrObjectSymbol>().mapTo(result) {
+        it.createLightClassNoCache(manager)
     }
 
+
     val jvmDefaultMode =
         classOrObject?.getKtModuleOfTypeSafe<KtSourceModule>()?.languageVersionSettings?.getFlag(JvmAnalysisFlags.jvmDefaultMode)
             ?: JvmDefaultMode.DEFAULT
@@ -439,22 +446,21 @@ internal fun KtSymbolWithMembers.createInnerClasses(
     return result
 }
 
+context(KtAnalysisSession)
 internal fun KtClassOrObject.checkIsInheritor(superClassOrigin: KtClassOrObject, checkDeep: Boolean): Boolean {
     if (this == superClassOrigin) return false
-    return analyseForLightClasses(this) {
-        if (!superClassOrigin.canBeAnalysed()) {
-            return false
-        }
-        val subClassSymbol = this@checkIsInheritor.getClassOrObjectSymbol()
-        val superClassSymbol = superClassOrigin.getClassOrObjectSymbol()
+    if (!superClassOrigin.canBeAnalysed()) {
+        return false
+    }
+    val subClassSymbol = this@checkIsInheritor.getClassOrObjectSymbol()
+    val superClassSymbol = superClassOrigin.getClassOrObjectSymbol()
 
-        if (subClassSymbol == superClassSymbol) return@analyseForLightClasses false
+    if (subClassSymbol == superClassSymbol) return false
 
-        if (checkDeep) {
-            subClassSymbol.isSubClassOf(superClassSymbol)
-        } else {
-            subClassSymbol.isDirectSubClassOf(superClassSymbol)
-        }
+    return if (checkDeep) {
+        subClassSymbol.isSubClassOf(superClassSymbol)
+    } else {
+        subClassSymbol.isDirectSubClassOf(superClassSymbol)
     }
 }
 

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

@@ -6,14 +6,16 @@
 package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.lifetime.isValid
+import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.analysis.api.lifetime.isValid
-import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.psi.KtEnumEntry
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
+context(KtAnalysisSession)
 internal class FirLightFieldForEnumEntry(
     private val enumEntrySymbol: KtEnumEntrySymbol,
     containingClass: FirLightClassForSymbol,
@@ -64,9 +66,7 @@ internal class FirLightFieldForEnumEntry(
     override fun getName(): String = enumEntrySymbol.name.asString()
 
     private val _type: PsiType by lazyPub {
-        analyzeWithSymbolAsContext(enumEntrySymbol) {
-            enumEntrySymbol.returnType.asPsiType(this@FirLightFieldForEnumEntry)
-        } ?: nonExistentType()
+        enumEntrySymbol.returnType.asPsiType(this@FirLightFieldForEnumEntry) ?: nonExistentType()
     }
 
     override fun getType(): PsiType = _type

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

@@ -7,13 +7,16 @@ package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
 import org.jetbrains.annotations.NotNull
+import org.jetbrains.kotlin.analysis.api.lifetime.isValid
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.analysis.api.lifetime.isValid
-import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.psi.KtDeclaration
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightFieldForObjectSymbol(
     private val objectSymbol: KtNamedClassOrObjectSymbol,
     containingClass: KtLightClass,
@@ -40,9 +43,8 @@ internal class FirLightFieldForObjectSymbol(
     override fun getModifierList(): PsiModifierList? = _modifierList
 
     private val _type: PsiType by lazyPub {
-        analyzeWithSymbolAsContext(objectSymbol) {
-            objectSymbol.buildSelfClassType().asPsiType(this@FirLightFieldForObjectSymbol)
-        } ?: nonExistentType()
+        objectSymbol.buildSelfClassType().asPsiType(this@FirLightFieldForObjectSymbol)
+            ?: nonExistentType()
     }
 
     private val _identifier: PsiIdentifier by lazyPub {

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

@@ -6,20 +6,22 @@
 package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
-import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
-import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
-import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
+import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
+import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.name.JvmNames.TRANSIENT_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.VOLATILE_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtProperty
 
+context(KtAnalysisSession)
 internal class FirLightFieldForPropertySymbol(
     private val propertySymbol: KtPropertySymbol,
     private val fieldName: String,
@@ -33,16 +35,14 @@ internal class FirLightFieldForPropertySymbol(
     override val kotlinOrigin: KtDeclaration? = propertySymbol.psi as? KtDeclaration
 
     private val _returnedType: PsiType by lazyPub {
-        analyzeWithSymbolAsContext(propertySymbol) {
-            val isDelegated = (propertySymbol as? KtKotlinPropertySymbol)?.isDelegatedProperty == true
-            when {
-                isDelegated ->
-                    (kotlinOrigin as? KtProperty)?.delegateExpression?.let {
-                        it.getKtType()?.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
-                    }
-                else -> {
-                    propertySymbol.returnType.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
+        val isDelegated = (propertySymbol as? KtKotlinPropertySymbol)?.isDelegatedProperty == true
+        when {
+            isDelegated ->
+                (kotlinOrigin as? KtProperty)?.delegateExpression?.let {
+                    it.getKtType()?.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
                 }
+            else -> {
+                propertySymbol.returnType.asPsiType(this@FirLightFieldForPropertySymbol, KtTypeMappingMode.RETURN_TYPE)
             }
         } ?: nonExistentType()
     }
@@ -94,9 +94,7 @@ internal class FirLightFieldForPropertySymbol(
         }
 
         val nullability = if (!(propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit)) {
-            analyzeWithSymbolAsContext(propertySymbol) {
-                getTypeNullability(propertySymbol.returnType)
-            }
+            getTypeNullability(propertySymbol.returnType)
         } else NullabilityType.Unknown
 
         val annotations = propertySymbol.computeAnnotations(

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

@@ -88,19 +88,16 @@ internal fun KtSymbolWithModality.computeModalityForMethod(
         result.add(PsiModifier.STATIC)
     }
 }
-
+context(KtAnalysisSession)
 internal fun PsiElement.tryGetEffectiveVisibility(symbol: KtCallableSymbol): Visibility? {
-
     if (symbol !is KtPropertySymbol && symbol !is KtFunctionSymbol) return null
 
     var visibility = (symbol as? KtSymbolWithVisibility)?.visibility
 
-    analyzeWithSymbolAsContext(symbol) {
-        for (overriddenSymbol in symbol.getAllOverriddenSymbols()) {
-            val newVisibility = (overriddenSymbol as? KtSymbolWithVisibility)?.visibility
-            if (newVisibility != null) {
-                visibility = newVisibility
-            }
+    for (overriddenSymbol in symbol.getAllOverriddenSymbols()) {
+        val newVisibility = (overriddenSymbol as? KtSymbolWithVisibility)?.visibility
+        if (newVisibility != null) {
+            visibility = newVisibility
         }
     }
 

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

@@ -5,34 +5,14 @@
 
 package org.jetbrains.kotlin.light.classes.symbol
 
-import com.intellij.openapi.project.Project
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiType
 import org.jetbrains.kotlin.analysis.api.KtAllowAnalysisOnEdt
-import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.lifetime.allowAnalysisOnEdt
 
 @OptIn(KtAllowAnalysisOnEdt::class)
 internal inline fun <E> allowLightClassesOnEdt(action: () -> E): E = allowAnalysisOnEdt(action)
 
-internal inline fun <R> PsiElement.analyzeWithSymbolAsContext(
-    contextSymbol: KtSymbol,
-    action: KtAnalysisSession.() -> R
-): R {
-    return project.analyzeWithSymbolAsContext(contextSymbol, action)
-}
-
-@OptIn(KtAnalysisApiInternals::class)
-internal inline fun <R> Project.analyzeWithSymbolAsContext(
-    contextSymbol: KtSymbol,
-    action: KtAnalysisSession.() -> R
-): R {
-    return KtAnalysisSessionProvider.getInstance(this).analyzeWithSymbolAsContext(contextSymbol, action)
-}
-
 internal fun PsiElement.nonExistentType(): PsiType =
     JavaPsiFacade.getElementFactory(project).createTypeFromText("error.NonExistentClass", this)

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

@@ -12,17 +12,16 @@ import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_FOR_SETTER
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
-import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyGetterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySetterSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.load.java.JvmAbi.getterName
 import org.jetbrains.kotlin.load.java.JvmAbi.setterName
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.symbols.*
 
+context(KtAnalysisSession)
 internal class FirLightAccessorMethodForSymbol(
     private val propertyAccessorSymbol: KtPropertyAccessorSymbol,
     private val containingPropertySymbol: KtPropertySymbol,
@@ -74,11 +73,7 @@ internal class FirLightAccessorMethodForSymbol(
                 !(isParameter && (containingClass.isAnnotationType || containingClass.isEnum))
 
         val nullabilityType = if (nullabilityApplicable) {
-            analyzeWithSymbolAsContext(containingPropertySymbol) {
-                getTypeNullability(
-                    containingPropertySymbol.returnType
-                )
-            }
+            getTypeNullability(containingPropertySymbol.returnType)
         } else NullabilityType.Unknown
 
         val annotationsFromProperty = containingPropertySymbol.computeAnnotations(
@@ -152,13 +147,11 @@ internal class FirLightAccessorMethodForSymbol(
 
     private val _returnedType: PsiType by lazyPub {
         if (!isGetter) return@lazyPub PsiType.VOID
-        analyzeWithSymbolAsContext(containingPropertySymbol) {
-            containingPropertySymbol.returnType.asPsiType(
-                this@FirLightAccessorMethodForSymbol,
-                KtTypeMappingMode.RETURN_TYPE,
-                containingClass.isAnnotationType
-            )
-        } ?: nonExistentType()
+        containingPropertySymbol.returnType.asPsiType(
+            this@FirLightAccessorMethodForSymbol,
+            KtTypeMappingMode.RETURN_TYPE,
+            containingClass.isAnnotationType
+        ) ?: nonExistentType()
     }
 
     override fun getReturnType(): PsiType = _returnedType
@@ -179,9 +172,7 @@ internal class FirLightAccessorMethodForSymbol(
             if (propertyParameter != null) {
                 builder.addParameter(
                     FirLightSetterParameterForSymbol(
-                        parameterSymbol = propertyParameter,
-                        containingPropertySymbol = containingPropertySymbol,
-                        containingMethod = this@FirLightAccessorMethodForSymbol
+                        containingPropertySymbol, propertyParameter, this@FirLightAccessorMethodForSymbol
                     )
                 )
             }

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

@@ -11,6 +11,9 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightConstructorForSymbol(
     private val constructorSymbol: KtConstructorSymbol,
     lightMemberOrigin: LightMemberOrigin?,

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

@@ -26,6 +26,9 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal abstract class FirLightMethod(
     lightMemberOrigin: LightMemberOrigin?,
     containingClass: KtLightClass,

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

@@ -7,14 +7,16 @@ package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.PsiIdentifier
 import com.intellij.psi.PsiParameterList
-import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
-import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
+import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.psi.KtDeclaration
 import java.util.*
 
+context(KtAnalysisSession)
 internal abstract class FirLightMethodForSymbol(
     private val functionSymbol: KtFunctionLikeSymbol,
     lightMemberOrigin: LightMemberOrigin?,

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

@@ -9,6 +9,9 @@ import com.intellij.psi.*
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightNoArgConstructor(
     lightMemberOrigin: LightMemberOrigin?,
     containingClass: FirLightClassBase,

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

@@ -6,17 +6,19 @@
 package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
-import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
+import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
+import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import java.util.*
 
+context(KtAnalysisSession)
 internal class FirLightSimpleMethodForSymbol(
     private val functionSymbol: KtFunctionSymbol,
     lightMemberOrigin: LightMemberOrigin?,
@@ -59,7 +61,7 @@ internal class FirLightSimpleMethodForSymbol(
         val nullability = if (isPrivate) {
             NullabilityType.Unknown
         } else {
-            analyzeWithSymbolAsContext(functionSymbol) l@{
+            run l@{
                 val ktType =
                     when {
                         functionSymbol.isSuspend -> // Any?
@@ -136,22 +138,19 @@ internal class FirLightSimpleMethodForSymbol(
         }
 
     private val _returnedType: PsiType by lazyPub {
-        analyzeWithSymbolAsContext(functionSymbol) {
-            val ktType =
-                when {
-                    functionSymbol.isSuspend -> // Any?
-                        analysisSession.builtinTypes.NULLABLE_ANY
-                    isVoidReturnType ->
-                        return@lazyPub PsiType.VOID
-                    else ->
-                        functionSymbol.returnType
-                }
-            ktType.asPsiType(
-                this@FirLightSimpleMethodForSymbol,
-                KtTypeMappingMode.RETURN_TYPE,
-                containingClass.isAnnotationType
-            )
-        } ?: nonExistentType()
+        val ktType = when {
+            functionSymbol.isSuspend -> // Any?
+                analysisSession.builtinTypes.NULLABLE_ANY
+            isVoidReturnType ->
+                return@lazyPub PsiType.VOID
+            else ->
+                functionSymbol.returnType
+        }
+        ktType.asPsiType(
+            this@FirLightSimpleMethodForSymbol,
+            KtTypeMappingMode.RETURN_TYPE,
+            containingClass.isAnnotationType
+        ) ?: nonExistentType()
     }
 
     override fun getReturnType(): PsiType = _returnedType

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

@@ -6,11 +6,13 @@
 package org.jetbrains.kotlin.light.classes.symbol
 
 import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
+import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.psi.KtParameter
 
+context(KtAnalysisSession)
 internal abstract class FirLightParameterBaseForSymbol(
     private val parameterSymbol: KtValueParameterSymbol,
     private val containingMethod: FirLightMethod
@@ -34,19 +36,14 @@ internal abstract class FirLightParameterBaseForSymbol(
             val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } &&
                     !containingMethod.hasModifierProperty(PsiModifier.PRIVATE)
 
-            return if (nullabilityApplicable) {
-                analyzeWithSymbolAsContext(parameterSymbol) {
-                    getTypeNullability(
-                        parameterSymbol.returnType
-                    )
-                }
-            } else NullabilityType.Unknown
+            return if (nullabilityApplicable) getTypeNullability(parameterSymbol.returnType)
+            else NullabilityType.Unknown
         }
 
     override fun getNameIdentifier(): PsiIdentifier = _identifier
 
     private val _type by lazyPub {
-        val convertedType = analyzeWithSymbolAsContext(parameterSymbol) {
+        val convertedType = run {
             val ktType = parameterSymbol.returnType
             val typeMappingMode = when {
                 ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT

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

@@ -9,16 +9,18 @@ import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiIdentifier
 import com.intellij.psi.PsiModifierList
 import com.intellij.psi.PsiType
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.annotations.annotations
-import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtNamedSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtType
+import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.psi.KtParameter
 
+context(KtAnalysisSession)
 internal class FirLightParameterForReceiver private constructor(
     private val receiverType: KtType,
     private val context: KtSymbol,
@@ -27,11 +29,11 @@ internal class FirLightParameterForReceiver private constructor(
 ) : FirLightParameter(method) {
 
     companion object {
+       context (KtAnalysisSession)
         fun tryGet(
             callableSymbol: KtCallableSymbol,
             method: FirLightMethod
         ): FirLightParameterForReceiver? {
-
             if (callableSymbol !is KtNamedSymbol) return null
 
             if (!callableSymbol.isExtension) return null
@@ -71,9 +73,7 @@ internal class FirLightParameterForReceiver private constructor(
     }
 
     private val _type: PsiType by lazyPub {
-        analyzeWithSymbolAsContext(context) {
-            receiverType.asPsiType(this@FirLightParameterForReceiver)
-        } ?: nonExistentType()
+        receiverType.asPsiType(this@FirLightParameterForReceiver) ?: nonExistentType()
     }
 
     override fun getType(): PsiType = _type

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

@@ -13,6 +13,9 @@ import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightParameterForSymbol(
     private val parameterSymbol: KtValueParameterSymbol,
     containingMethod: FirLightMethod

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

@@ -15,6 +15,9 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtParameterList
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightParameterList(
     private val parent: FirLightMethod,
     private val callableSymbol: KtCallableSymbol?,

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

@@ -13,6 +13,9 @@ import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightSetterParameterForSymbol(
     private val containingPropertySymbol: KtPropertySymbol,
     private val parameterSymbol: KtValueParameterSymbol,

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

@@ -18,6 +18,9 @@ import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAM
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtParameter
 
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+
+context(KtAnalysisSession)
 internal class FirLightSuspendContinuationParameter(
     private val functionSymbol: KtFunctionSymbol,
     private val containingMethod: FirLightMethod,
@@ -33,11 +36,9 @@ internal class FirLightSuspendContinuationParameter(
     override fun getType(): PsiType = _type
 
     private val _type by lazyPub {
-        analyzeWithSymbolAsContext(functionSymbol) {
-            buildClassType(StandardClassIds.Continuation) {
-                argument(functionSymbol.returnType)
-            }.asPsiType(this@FirLightSuspendContinuationParameter)
-        } ?: nonExistentType()
+        buildClassType(StandardClassIds.Continuation) { argument(functionSymbol.returnType) }
+            .asPsiType(this)
+            ?: nonExistentType()
     }
 
     override fun isVarArgs(): Boolean = false

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

@@ -13,6 +13,7 @@ import com.intellij.psi.impl.PsiClassImplUtil
 import com.intellij.psi.impl.light.LightElement
 import com.intellij.psi.javadoc.PsiDocComment
 import com.intellij.psi.search.SearchScope
+import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtClassErrorType
@@ -23,11 +24,15 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.light.classes.symbol.*
+import org.jetbrains.kotlin.light.classes.symbol.FirLightTypeParameterListForSymbol
+import org.jetbrains.kotlin.light.classes.symbol.basicIsEquivalentTo
+import org.jetbrains.kotlin.light.classes.symbol.invalidAccess
+import org.jetbrains.kotlin.light.classes.symbol.mapSuperType
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtTypeParameter
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
+context(KtAnalysisSession)
 internal class FirLightTypeParameter(
     private val parent: FirLightTypeParameterListForSymbol,
     private val index: Int,
@@ -58,20 +63,18 @@ internal class FirLightTypeParameter(
             language = language,
             role = PsiReferenceList.Role.EXTENDS_LIST
         )
-        analyzeWithSymbolAsContext(typeParameterSymbol) {
-            typeParameterSymbol.upperBounds
-                .filter { type ->
-                    when (type) {
-                        is KtNonErrorClassType -> type.classId != StandardClassIds.Any
-                        is KtClassErrorType -> false
-                        else -> true
-                    }
+        typeParameterSymbol.upperBounds
+            .filter { type ->
+                when (type) {
+                    is KtNonErrorClassType -> type.classId != StandardClassIds.Any
+                    is KtClassErrorType -> false
+                    else -> true
                 }
-                .mapNotNull {
-                    mapSuperType(it, this@FirLightTypeParameter, kotlinCollectionAsIs = true)
-                }
-                .forEach { listBuilder.addReference(it) }
-        }
+            }
+            .mapNotNull {
+                mapSuperType(it, this@FirLightTypeParameter, kotlinCollectionAsIs = true)
+            }
+            .forEach { listBuilder.addReference(it) }
 
         listBuilder
     }