[SLC] drop KtAnalysisSession from SymbolLightAccessorMethod

^KT-54051

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

@@ -262,7 +262,7 @@ internal fun SymbolLightClassBase.createPropertyAccessors(
         return true
     }
 
-    val originalElement = declaration.psi as? KtDeclaration
+    val originalElement = declaration.sourcePsiSafe<KtDeclaration>()
 
     val getter = declaration.getter?.takeIf {
         it.needToCreateAccessor(AnnotationUseSiteTarget.PROPERTY_GETTER)
@@ -273,7 +273,7 @@ internal fun SymbolLightClassBase.createPropertyAccessors(
             LightMemberOriginForDeclaration(
                 originalElement = it,
                 originKind = JvmDeclarationOriginKind.OTHER,
-                auxiliaryOriginalElement = getter.psi as? KtDeclaration
+                auxiliaryOriginalElement = getter.sourcePsiSafe<KtDeclaration>()
             )
         }
 
@@ -285,6 +285,7 @@ internal fun SymbolLightClassBase.createPropertyAccessors(
                 containingClass = this@createPropertyAccessors,
                 isTopLevel = isTopLevel,
                 suppressStatic = suppressStatic,
+                ktModule = ktModule,
             )
         )
     }
@@ -298,9 +299,10 @@ internal fun SymbolLightClassBase.createPropertyAccessors(
             LightMemberOriginForDeclaration(
                 originalElement = it,
                 originKind = JvmDeclarationOriginKind.OTHER,
-                auxiliaryOriginalElement = setter.psi as? KtDeclaration
+                auxiliaryOriginalElement = setter.sourcePsiSafe<KtDeclaration>()
             )
         }
+
         result.add(
             SymbolLightAccessorMethod(
                 propertyAccessorSymbol = setter,
@@ -309,6 +311,7 @@ internal fun SymbolLightClassBase.createPropertyAccessors(
                 containingClass = this@createPropertyAccessors,
                 isTopLevel = isTopLevel,
                 suppressStatic = suppressStatic,
+                ktModule = ktModule,
             )
         )
     }

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

@@ -7,16 +7,15 @@ package org.jetbrains.kotlin.light.classes.symbol.methods
 
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
+import com.intellij.psi.impl.light.LightParameterListBuilder
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtConstantValueForAnnotation
 import org.jetbrains.kotlin.analysis.api.KtNonConstantInitializerValue
-import org.jetbrains.kotlin.analysis.api.lifetime.isValid
+import org.jetbrains.kotlin.analysis.api.symbols.*
-import org.jetbrains.kotlin.analysis.api.symbols.KtPropertyAccessorSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
-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.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_FOR_GETTER
 import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_FOR_SETTER
@@ -28,40 +27,62 @@ import org.jetbrains.kotlin.light.classes.symbol.annotations.getJvmNameFromAnnot
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmStaticAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
+import org.jetbrains.kotlin.light.classes.symbol.classes.analyzeForLightClasses
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightParameterList
 import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightSetterParameter
 import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightTypeParameterList
 import org.jetbrains.kotlin.load.java.JvmAbi.getterName
 import org.jetbrains.kotlin.load.java.JvmAbi.setterName
+import org.jetbrains.kotlin.psi.KtCallableDeclaration
+import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtPropertyAccessor
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
-context(KtAnalysisSession)
 internal class SymbolLightAccessorMethod(
-    private val propertyAccessorSymbol: KtPropertyAccessorSymbol,
+    propertyAccessorSymbol: KtPropertyAccessorSymbol,
-    private val containingPropertySymbol: KtPropertySymbol,
+    containingPropertySymbol: KtPropertySymbol,
     lightMemberOrigin: LightMemberOrigin?,
     containingClass: SymbolLightClassBase,
     private val isTopLevel: Boolean,
     private val suppressStatic: Boolean = false,
+    private val ktModule: KtModule,
 ) : SymbolLightMethodBase(
     lightMemberOrigin,
     containingClass,
-    if (propertyAccessorSymbol is KtPropertyGetterSymbol) METHOD_INDEX_FOR_GETTER else METHOD_INDEX_FOR_SETTER
+    if (propertyAccessorSymbol is KtPropertyGetterSymbol) METHOD_INDEX_FOR_GETTER else METHOD_INDEX_FOR_SETTER,
 ) {
-    private val isGetter: Boolean get() = propertyAccessorSymbol is KtPropertyGetterSymbol
+    private val isGetter: Boolean = propertyAccessorSymbol is KtPropertyGetterSymbol
 
-    private fun String.abiName() =
+    private val propertyAccessorDeclaration: KtPropertyAccessor? = propertyAccessorSymbol.sourcePsiSafe()
-        if (isGetter) getterName(this) else setterName(this)
+    private val propertyAccessorSymbolPointer: KtSymbolPointer<KtPropertyAccessorSymbol> = propertyAccessorSymbol.createPointer()
+
+    context(KtAnalysisSession)
+    private fun propertyAccessorSymbol(): KtPropertyAccessorSymbol {
+        return propertyAccessorSymbolPointer.restoreSymbolOrThrowIfDisposed()
+    }
+
+    private val containingPropertyDeclaration: KtCallableDeclaration? = containingPropertySymbol.sourcePsiSafe()
+    private val containingPropertySymbolPointer: KtSymbolPointer<KtPropertySymbol> = containingPropertySymbol.createPointer()
+
+    context(KtAnalysisSession)
+    private fun propertySymbol(): KtPropertySymbol {
+        return containingPropertySymbolPointer.restoreSymbolOrThrowIfDisposed()
+    }
+
+    private fun String.abiName() = if (isGetter) getterName(this) else setterName(this)
 
     private val _name: String by lazyPub {
-        propertyAccessorSymbol.getJvmNameFromAnnotation(accessorSite) ?: run {
+        analyzeForLightClasses(ktModule) {
-            val defaultName = containingPropertySymbol.name.identifier.let {
+            propertyAccessorSymbol().getJvmNameFromAnnotation(accessorSite) ?: run {
-                if (containingClass.isAnnotationType) it else it.abiName()
+                val symbol = propertySymbol()
-            }
+                val defaultName = symbol.name.identifier.let {
+                    if (containingClass.isAnnotationType) it else it.abiName()
+                }
 
-            containingPropertySymbol.computeJvmMethodName(defaultName, containingClass, accessorSite)
+                symbol.computeJvmMethodName(defaultName, containingClass, accessorSite)
+            }
         }
     }
 
@@ -69,72 +90,76 @@ internal class SymbolLightAccessorMethod(
 
     private val _typeParameterList: PsiTypeParameterList? by lazyPub {
         hasTypeParameters().ifTrue {
-            SymbolLightTypeParameterList(
+            analyzeForLightClasses(ktModule) {
-                owner = this,
+                SymbolLightTypeParameterList(
-                symbolWithTypeParameterList = containingPropertySymbol,
+                    owner = this@SymbolLightAccessorMethod,
-            )
+                    symbolWithTypeParameterList = propertySymbol(),
+                )
+            }
         }
     }
 
-    override fun hasTypeParameters(): Boolean = containingPropertySymbol.typeParameters.isNotEmpty()
+    override fun hasTypeParameters(): Boolean =
+        containingPropertyDeclaration?.typeParameters?.isNotEmpty() ?: analyzeForLightClasses(ktModule) {
+            propertySymbol().typeParameters.isNotEmpty()
+        }
+
     override fun getTypeParameterList(): PsiTypeParameterList? = _typeParameterList
     override fun getTypeParameters(): Array<PsiTypeParameter> = _typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY
 
     override fun isVarArgs(): Boolean = false
 
+    override val kotlinOrigin: KtDeclaration? get() = containingPropertyDeclaration
+
     private val accessorSite
-        get() =
+        get() = if (isGetter) AnnotationUseSiteTarget.PROPERTY_GETTER else AnnotationUseSiteTarget.PROPERTY_SETTER
-            if (propertyAccessorSymbol is KtPropertyGetterSymbol) AnnotationUseSiteTarget.PROPERTY_GETTER
-            else AnnotationUseSiteTarget.PROPERTY_SETTER
 
     //TODO Fix it when SymbolConstructorValueParameter be ready
-    private val isParameter: Boolean get() = containingPropertySymbol.psi.let { it == null || it is KtParameter }
+    private val isParameter: Boolean get() = containingPropertyDeclaration == null || containingPropertyDeclaration is KtParameter
 
-    private fun computeAnnotations(isPrivate: Boolean): List<PsiAnnotation> {
+    private fun computeAnnotations(isPrivate: Boolean): List<PsiAnnotation> = analyzeForLightClasses(ktModule) {
-        val nullabilityApplicable = isGetter &&
+        val nullabilityApplicable = isGetter && !isPrivate && !(isParameter && containingClass.isAnnotationType)
-                !isPrivate &&
-                !(isParameter && containingClass.isAnnotationType)
 
-        val nullabilityType = if (nullabilityApplicable) {
+        val propertySymbol = propertySymbol()
-            getTypeNullability(containingPropertySymbol.returnType)
+        val nullabilityType = if (nullabilityApplicable) getTypeNullability(propertySymbol.returnType) else NullabilityType.Unknown
-        } else NullabilityType.Unknown
+        val annotationsFromProperty = propertySymbol.computeAnnotations(
-
+            parent = this@SymbolLightAccessorMethod,
-        val annotationsFromProperty = containingPropertySymbol.computeAnnotations(
-            parent = this,
             nullability = nullabilityType,
             annotationUseSiteTarget = accessorSite,
-            includeAnnotationsWithoutSite = false
+            includeAnnotationsWithoutSite = false,
         )
 
+        val propertyAccessorSymbol = propertyAccessorSymbol()
         val annotationsFromAccessor = propertyAccessorSymbol.computeAnnotations(
-            parent = this,
+            parent = this@SymbolLightAccessorMethod,
             nullability = NullabilityType.Unknown,
             annotationUseSiteTarget = accessorSite,
         )
 
-        return annotationsFromProperty + annotationsFromAccessor
+        annotationsFromProperty + annotationsFromAccessor
     }
 
-    private fun computeModifiers(): Set<String> {
+    private fun computeModifiers(): Set<String> = analyzeForLightClasses(ktModule) {
-        val isOverrideMethod = propertyAccessorSymbol.isOverride || containingPropertySymbol.isOverride
+        val propertySymbol = propertySymbol()
+        val propertyAccessorSymbol = propertyAccessorSymbol()
+        val isOverrideMethod = propertyAccessorSymbol.isOverride || propertySymbol.isOverride
         val isInterfaceMethod = containingClass.isInterface
 
         val modifiers = mutableSetOf<String>()
 
-        containingPropertySymbol.computeModalityForMethod(
+        propertySymbol.computeModalityForMethod(
             isTopLevel = isTopLevel,
             suppressFinal = isOverrideMethod || isInterfaceMethod,
-            result = modifiers
+            result = modifiers,
         )
 
         val visibility = isOverrideMethod.ifTrue {
-            tryGetEffectiveVisibility(containingPropertySymbol)
+            tryGetEffectiveVisibility(propertySymbol)?.toPsiVisibilityForMember()
-                ?.toPsiVisibilityForMember()
         } ?: propertyAccessorSymbol.toPsiVisibilityForMember()
         modifiers.add(visibility)
 
         if (!suppressStatic &&
-            (containingPropertySymbol.hasJvmStaticAnnotation() || propertyAccessorSymbol.hasJvmStaticAnnotation(accessorSite))
+            (propertySymbol.hasJvmStaticAnnotation() || propertyAccessorSymbol.hasJvmStaticAnnotation(accessorSite))
         ) {
             modifiers.add(PsiModifier.STATIC)
         }
@@ -143,7 +168,7 @@ internal class SymbolLightAccessorMethod(
             modifiers.add(PsiModifier.ABSTRACT)
         }
 
-        return modifiers
+        modifiers
     }
 
     private val _modifierList: PsiModifierList by lazyPub {
@@ -157,69 +182,95 @@ internal class SymbolLightAccessorMethod(
     override fun isConstructor(): Boolean = false
 
     private val _isDeprecated: Boolean by lazyPub {
-        containingPropertySymbol.hasDeprecatedAnnotation(accessorSite)
+        analyzeForLightClasses(ktModule) {
+            propertySymbol().hasDeprecatedAnnotation(accessorSite)
+        }
     }
 
     override fun isDeprecated(): Boolean = _isDeprecated
 
     private val _identifier: PsiIdentifier by lazyPub {
-        SymbolLightIdentifier(this, containingPropertySymbol)
+        analyzeForLightClasses(ktModule) {
+            SymbolLightIdentifier(this@SymbolLightAccessorMethod, propertySymbol())
+        }
     }
 
     override fun getNameIdentifier(): PsiIdentifier = _identifier
 
     private val _returnedType: PsiType by lazyPub {
         if (!isGetter) return@lazyPub PsiType.VOID
-        containingPropertySymbol.returnType.asPsiType(
+        analyzeForLightClasses(ktModule) {
-            this@SymbolLightAccessorMethod,
+            propertySymbol().returnType.asPsiType(
-            KtTypeMappingMode.RETURN_TYPE,
+                this@SymbolLightAccessorMethod,
-            containingClass.isAnnotationType
+                KtTypeMappingMode.RETURN_TYPE,
-        ) ?: nonExistentType()
+                containingClass.isAnnotationType,
+            )
+        } ?: nonExistentType()
     }
 
     override fun getReturnType(): PsiType = _returnedType
 
-    override fun equals(other: Any?): Boolean =
+    override fun equals(other: Any?): Boolean {
-        this === other ||
+        if (this === other) return true
-                (other is SymbolLightAccessorMethod &&
+        if (other !is SymbolLightAccessorMethod) return false
-                        isGetter == other.isGetter &&
+        if (propertyAccessorDeclaration != null) {
-                        kotlinOrigin == other.kotlinOrigin &&
+            return propertyAccessorDeclaration == other.propertyAccessorDeclaration && ktModule == other.ktModule
-                        propertyAccessorSymbol == other.propertyAccessorSymbol)
+        }
 
-    override fun hashCode(): Int = kotlinOrigin.hashCode()
+        return isGetter == other.isGetter &&
+                other.propertyAccessorDeclaration == null &&
+                ktModule == other.ktModule &&
+                analyzeForLightClasses(ktModule) {
+                    propertyAccessorSymbolPointer.restoreSymbol() == other.propertyAccessorSymbolPointer.restoreSymbol()
+                }
+    }
+
+    override fun hashCode(): Int = propertyAccessorDeclaration.hashCode()
 
     private val _parametersList by lazyPub {
-        SymbolLightParameterList(this, containingPropertySymbol) { builder ->
+        val parameterPopulator: (LightParameterListBuilder) -> Unit = if (!isGetter) {
-            val propertyParameter = (propertyAccessorSymbol as? KtPropertySetterSymbol)?.parameter
+            { builder ->
-            if (propertyParameter != null) {
+                analyzeForLightClasses(ktModule) {
-                builder.addParameter(
+                    val propertyParameter = (propertyAccessorSymbol() as? KtPropertySetterSymbol)?.parameter
-                    SymbolLightSetterParameter(
+                    if (propertyParameter != null) {
-                        containingPropertySymbol, propertyParameter, this@SymbolLightAccessorMethod
+                        builder.addParameter(
-                    )
+                            SymbolLightSetterParameter(
-                )
+                                propertySymbol(), propertyParameter, this@SymbolLightAccessorMethod
+                            )
+                        )
+                    }
+                }
             }
+        } else {
+            { }
+        }
+
+        analyzeForLightClasses(ktModule) {
+            SymbolLightParameterList(this@SymbolLightAccessorMethod, propertySymbol(), parameterPopulator)
         }
     }
 
     override fun getParameterList(): PsiParameterList = _parametersList
 
-    override fun isValid(): Boolean = super.isValid() && propertyAccessorSymbol.isValid()
+    override fun isValid(): Boolean = super.isValid() &&
+            propertyAccessorDeclaration?.isValid ?: analyzeForLightClasses(ktModule) { propertyAccessorSymbolPointer.restoreSymbol() != null }
 
-    override fun isOverride(): Boolean = propertyAccessorSymbol.isOverride
+    override fun isOverride(): Boolean = analyzeForLightClasses(ktModule) { propertyAccessorSymbol().isOverride }
 
     private val _defaultValue: PsiAnnotationMemberValue? by lazyPub {
         if (!containingClass.isAnnotationType) return@lazyPub null
-        when (val initializer = containingPropertySymbol.initializer) {
+
-            is KtConstantInitializerValue -> initializer.constant.createPsiLiteral(this)
+        analyzeForLightClasses(ktModule) {
-            is KtConstantValueForAnnotation -> initializer.annotationValue.toAnnotationMemberValue(this)
+            when (val initializer = propertySymbol().initializer) {
-            is KtNonConstantInitializerValue -> null
+                is KtConstantInitializerValue -> initializer.constant.createPsiLiteral(this@SymbolLightAccessorMethod)
-            null -> null
+                is KtConstantValueForAnnotation -> initializer.annotationValue.toAnnotationMemberValue(this@SymbolLightAccessorMethod)
+                is KtNonConstantInitializerValue -> null
+                null -> null
+            }
         }
     }
 
-    override fun getDefaultValue(): PsiAnnotationMemberValue? {
+    override fun getDefaultValue(): PsiAnnotationMemberValue? = _defaultValue
-        return _defaultValue
-    }
 
     override fun getText(): String {
         return lightMemberOrigin?.auxiliaryOriginalElement?.text ?: super.getText()