[SLC] reduce amount usages of analyzeForLightClasses

^KT-56046

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

@@ -130,8 +130,8 @@ internal class SymbolLightAccessorMethod private constructor(
     private val isParameter: Boolean get() = containingPropertyDeclaration == null || containingPropertyDeclaration is KtParameter
 
     override fun computeThrowsList(builder: LightReferenceListBuilder) {
-        analyzeForLightClasses(ktModule) {
-            propertyAccessorSymbol().computeThrowsList(
+        propertyAccessorSymbolPointer.withSymbol(ktModule) { accessorSymbol ->
+            accessorSymbol.computeThrowsList(
                 builder,
                 accessorSite,
                 this@SymbolLightAccessorMethod,
@@ -148,8 +148,7 @@ internal class SymbolLightAccessorMethod private constructor(
             val modality = if (containingClass.isInterface) {
                 PsiModifier.ABSTRACT
             } else {
-                analyzeForLightClasses(ktModule) {
-                    val propertySymbol = propertySymbol()
+                containingPropertySymbolPointer.withSymbol(ktModule) { propertySymbol ->
                     propertySymbol.computeSimpleModality()?.takeUnless { it.isSuppressedFinalModifier(containingClass, propertySymbol) }
                 }
             }
@@ -201,8 +200,8 @@ internal class SymbolLightAccessorMethod private constructor(
                             !modifierList.hasModifierProperty(PsiModifier.PRIVATE)
 
                     if (nullabilityApplicable) {
-                        analyzeForLightClasses(ktModule) {
-                            getTypeNullability(propertySymbol().returnType)
+                        containingPropertySymbolPointer.withSymbol(ktModule) { propertySymbol ->
+                            getTypeNullability(propertySymbol.returnType)
                         }
                     } else {
                         NullabilityType.Unknown
@@ -233,8 +232,9 @@ internal class SymbolLightAccessorMethod private constructor(
 
     private val _returnedType: PsiType by lazyPub {
         if (!isGetter) return@lazyPub PsiType.VOID
-        analyzeForLightClasses(ktModule) {
-            propertySymbol().returnType.asPsiType(
+
+        containingPropertySymbolPointer.withSymbol(ktModule) { propertySymbol ->
+            propertySymbol.returnType.asPsiType(
                 this@SymbolLightAccessorMethod,
                 allowErrorTypes = true,
                 KtTypeMappingMode.RETURN_TYPE,
@@ -270,18 +270,16 @@ internal class SymbolLightAccessorMethod private constructor(
     private val _parametersList by lazyPub {
         val parameterPopulator: (LightParameterListBuilder) -> Unit = if (!isGetter) {
             { builder ->
-                analyzeForLightClasses(ktModule) {
-                    val propertyParameter = (propertyAccessorSymbol() as? KtPropertySetterSymbol)?.parameter
-                    if (propertyParameter != null) {
-                        builder.addParameter(
-                            SymbolLightSetterParameter(
-                                ktAnalysisSession = this,
-                                containingPropertySymbolPointer = containingPropertySymbolPointer,
-                                parameterSymbol = propertyParameter,
-                                containingMethod = this@SymbolLightAccessorMethod,
-                            )
+                propertyAccessorSymbolPointer.withSymbol(ktModule) { accessorSymbol ->
+                    val setterParameter = (accessorSymbol as? KtPropertySetterSymbol)?.parameter ?: return@withSymbol
+                    builder.addParameter(
+                        SymbolLightSetterParameter(
+                            ktAnalysisSession = this,
+                            containingPropertySymbolPointer = containingPropertySymbolPointer,
+                            parameterSymbol = setterParameter,
+                            containingMethod = this@SymbolLightAccessorMethod,
                         )
-                    }
+                    )
                 }
             }
         } else {
@@ -301,7 +299,13 @@ internal class SymbolLightAccessorMethod private constructor(
         super.isValid() && propertyAccessorDeclaration?.isValid ?: propertyAccessorSymbolPointer.isValid(ktModule)
 
     private val _isOverride: Boolean by lazyPub {
-        if (isTopLevel) false else analyzeForLightClasses(ktModule) { propertyAccessorSymbol().isOverride }
+        if (isTopLevel) {
+            false
+        } else {
+            propertyAccessorSymbolPointer.withSymbol(ktModule) { accessorSymbol ->
+                accessorSymbol.isOverride
+            }
+        }
     }
 
     override fun isOverride(): Boolean = _isOverride
@@ -309,8 +313,8 @@ internal class SymbolLightAccessorMethod private constructor(
     private val _defaultValue: PsiAnnotationMemberValue? by lazyPub {
         if (!containingClass.isAnnotationType) return@lazyPub null
 
-        analyzeForLightClasses(ktModule) {
-            when (val initializer = propertySymbol().initializer) {
+        containingPropertySymbolPointer.withSymbol(ktModule) { propertySymbol ->
+            when (val initializer = propertySymbol.initializer) {
                 is KtConstantInitializerValue -> initializer.constant.createPsiLiteral(this@SymbolLightAccessorMethod)
                 is KtConstantValueForAnnotation -> initializer.annotationValue.toAnnotationMemberValue(this@SymbolLightAccessorMethod)
                 is KtNonConstantInitializerValue -> null

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

@@ -12,10 +12,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithModality
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.light.classes.symbol.analyzeForLightClasses
 import org.jetbrains.kotlin.light.classes.symbol.computeSimpleModality
-import org.jetbrains.kotlin.light.classes.symbol.restoreSymbolOrThrowIfDisposed
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForMember
+import org.jetbrains.kotlin.light.classes.symbol.withSymbol
 import org.jetbrains.kotlin.utils.keysToMap
 import java.util.concurrent.atomic.AtomicReference
 
@@ -54,8 +53,8 @@ internal class LazyModifiersBox(
             ktModule: KtModule,
             declarationPointer: KtSymbolPointer<KtSymbolWithVisibility>,
         ): PersistentMap<String, Boolean> {
-            val visibility = analyzeForLightClasses(ktModule) {
-                declarationPointer.restoreSymbolOrThrowIfDisposed().toPsiVisibilityForMember()
+            val visibility = declarationPointer.withSymbol(ktModule) {
+                it.toPsiVisibilityForMember()
             }
 
             return VISIBILITY_MODIFIERS_MAP.with(visibility)
@@ -65,8 +64,8 @@ internal class LazyModifiersBox(
             ktModule: KtModule,
             declarationPointer: KtSymbolPointer<KtSymbolWithModality>,
         ): PersistentMap<String, Boolean> {
-            val modality = analyzeForLightClasses(ktModule) {
-                declarationPointer.restoreSymbolOrThrowIfDisposed().computeSimpleModality()
+            val modality = declarationPointer.withSymbol(ktModule) {
+                it.computeSimpleModality()
             }
 
             return MODALITY_MODIFIERS_MAP.with(modality)

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

@@ -29,21 +29,17 @@ internal class SymbolLightParameterForReceiver private constructor(
     methodName: String,
     method: SymbolLightMethodBase,
 ) : SymbolLightParameterBase(method) {
-    private inline fun <T> withReceiverSymbol(crossinline action: context(KtAnalysisSession) (KtReceiverParameterSymbol) -> T): T {
-        return analyzeForLightClasses(ktModule) {
-            action(this, receiverPointer.restoreSymbolOrThrowIfDisposed())
-        }
-    }
+    private inline fun <T> withReceiverSymbol(crossinline action: context(KtAnalysisSession) (KtReceiverParameterSymbol) -> T): T =
+        receiverPointer.withSymbol(ktModule, action)
 
     companion object {
         fun tryGet(
             callableSymbolPointer: KtSymbolPointer<KtCallableSymbol>,
             method: SymbolLightMethodBase
-        ): SymbolLightParameterForReceiver? = analyzeForLightClasses(method.ktModule) {
-            val callableSymbol = callableSymbolPointer.restoreSymbolOrThrowIfDisposed()
-            if (callableSymbol !is KtNamedSymbol) return@analyzeForLightClasses null
-            if (!callableSymbol.isExtension) return@analyzeForLightClasses null
-            val receiverSymbol = callableSymbol.receiverParameter ?: return@analyzeForLightClasses null
+        ): SymbolLightParameterForReceiver? = callableSymbolPointer.withSymbol(method.ktModule) { callableSymbol ->
+            if (callableSymbol !is KtNamedSymbol) return@withSymbol null
+            if (!callableSymbol.isExtension) return@withSymbol null
+            val receiverSymbol = callableSymbol.receiverParameter ?: return@withSymbol null
 
             SymbolLightParameterForReceiver(
                 receiverPointer = receiverSymbol.createPointer(),