[SLC] drop KtAnalysisSession from SymbolLightParameterCommon

^KT-54051

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

@@ -227,7 +227,7 @@ internal class SymbolLightAccessorMethod(
                     if (propertyParameter != null) {
                         builder.addParameter(
                             SymbolLightSetterParameter(
-                                propertySymbol(), propertyParameter, this@SymbolLightAccessorMethod
+                                containingPropertySymbolPointer, propertyParameter, this@SymbolLightAccessorMethod
                             )
                         )
                     }

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

@@ -7,8 +7,6 @@ package org.jetbrains.kotlin.light.classes.symbol.parameters
 
 import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiModifierList
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
@@ -16,14 +14,13 @@ import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.withSymbol
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
-context(KtAnalysisSession)
 internal class SymbolLightParameter(
-    private val parameterSymbol: KtValueParameterSymbol,
+    parameterSymbol: KtValueParameterSymbol,
     containingMethod: SymbolLightMethodBase
 ) : SymbolLightParameterCommon(parameterSymbol, containingMethod) {
-
     private val isConstructorParameterSymbol = containingMethod.isConstructor
 
     private val _annotations: List<PsiAnnotation> by lazyPub {
@@ -32,28 +29,27 @@ internal class SymbolLightParameter(
             AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER
         }
 
-        val nullability = if (parameterSymbol.isVararg) NullabilityType.NotNull else super.nullabilityType
+        parameterSymbolPointer.withSymbol(ktModule) { parameterSymbol ->
+            val nullability = if (parameterSymbol.isVararg) NullabilityType.NotNull else super.nullabilityType
 
-        parameterSymbol.computeAnnotations(
+            parameterSymbol.computeAnnotations(
-            parent = this,
+                parent = this,
-            nullability = nullability,
+                nullability = nullability,
-            annotationUseSiteTarget = annotationSite,
+                annotationUseSiteTarget = annotationSite,
-            includeAnnotationsWithoutSite = true
+                includeAnnotationsWithoutSite = true
-        )
+            )
+        }
     }
 
     override fun getModifierList(): PsiModifierList = _modifierList
+
     private val _modifierList: PsiModifierList by lazyPub {
         SymbolLightClassModifierList(this, lazyOf(emptySet()), lazyOf(_annotations))
     }
 
-    override fun isVarArgs() = parameterSymbol.isVararg
+    private val isVararg: Boolean by lazy {
+        parameterSymbolPointer.withSymbol(ktModule) { it.isVararg }
+    }
 
-    override fun equals(other: Any?): Boolean =
+    override fun isVarArgs() = isVararg
-        this === other ||
-                (other is SymbolLightParameter && parameterSymbol == other.parameterSymbol)
-
-    override fun hashCode(): Int = kotlinOrigin.hashCode()
-
-    override fun isValid(): Boolean = super.isValid() && parameterSymbol.isValid()
 }

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

@@ -6,66 +6,89 @@
 package org.jetbrains.kotlin.light.classes.symbol.parameters
 
 import com.intellij.psi.*
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
+import org.jetbrains.kotlin.analysis.api.symbols.sourcePsiSafe
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
+import org.jetbrains.kotlin.asJava.elements.KtLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.*
-import org.jetbrains.kotlin.light.classes.symbol.getTypeNullability
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
-import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.psi.KtParameter
 
-context(KtAnalysisSession)
 internal abstract class SymbolLightParameterCommon(
-    private val parameterSymbol: KtValueParameterSymbol,
+    parameterSymbol: KtValueParameterSymbol,
     private val containingMethod: SymbolLightMethodBase
 ) : SymbolLightParameterBase(containingMethod) {
-    private val _name: String = parameterSymbol.name.asString()
+    protected val parameterSymbolPointer: KtSymbolPointer<KtValueParameterSymbol> = parameterSymbol.createPointer()
+    protected val parameterDeclaration: KtParameter? = parameterSymbol.sourcePsiSafe()
+
+    private val _name: String by lazy {
+        parameterSymbolPointer.withSymbol(ktModule) {
+            it.name.asString()
+        }
+    }
+
     override fun getName(): String = _name
 
-    override fun hasModifierProperty(name: String): Boolean =
+    override fun hasModifierProperty(name: String): Boolean = modifierList.hasModifierProperty(name)
-        modifierList.hasModifierProperty(name)
 
-    override val kotlinOrigin: KtParameter? = parameterSymbol.psi as? KtParameter
+    override val kotlinOrigin: KtParameter? = parameterDeclaration ?: parameterSymbol.psi as? KtParameter
 
     abstract override fun getModifierList(): PsiModifierList
 
-    private val _identifier: PsiIdentifier by lazyPub {
+    private val _identifier: PsiIdentifier by lazy {
-        SymbolLightIdentifier(this, parameterSymbol)
+        KtLightIdentifier(this, parameterDeclaration)
     }
 
-    protected val nullabilityType: NullabilityType
+    protected val nullabilityType: NullabilityType by lazyPub {
-        get() {
+        val nullabilityApplicable = !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) &&
-            val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } &&
+                !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum }
-                    !containingMethod.hasModifierProperty(PsiModifier.PRIVATE)
 
-            return if (nullabilityApplicable) getTypeNullability(parameterSymbol.returnType)
+        if (nullabilityApplicable) {
-            else NullabilityType.Unknown
+            parameterSymbolPointer.withSymbol(ktModule) { getTypeNullability(it.returnType) }
+        } else {
+            NullabilityType.Unknown
         }
+    }
 
     override fun getNameIdentifier(): PsiIdentifier = _identifier
 
-    private val _type by lazyPub {
+    private val _type by lazy {
-        val convertedType = run {
+        parameterSymbolPointer.withSymbol(ktModule) { parameterSymbol ->
-            val ktType = parameterSymbol.returnType
+            val convertedType = run {
-            val typeMappingMode = when {
+                val ktType = parameterSymbol.returnType
-                ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT
+                val typeMappingMode = when {
-                // TODO: extract type mapping mode from annotation?
+                    ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT
-                // TODO: methods with declaration site wildcards?
+                    // TODO: extract type mapping mode from annotation?
-                else -> KtTypeMappingMode.VALUE_PARAMETER
+                    // TODO: methods with declaration site wildcards?
+                    else -> KtTypeMappingMode.VALUE_PARAMETER
+                }
+
+                ktType.asPsiType(this@SymbolLightParameterCommon, typeMappingMode)
+            } ?: nonExistentType()
+
+            if (parameterSymbol.isVararg) {
+                PsiEllipsisType(convertedType, convertedType.annotationProvider)
+            } else {
+                convertedType
             }
-            ktType.asPsiType(this@SymbolLightParameterCommon, typeMappingMode)
+        }
-        } ?: nonExistentType()
-        if (parameterSymbol.isVararg) {
-            PsiEllipsisType(convertedType, convertedType.annotationProvider)
-        } else convertedType
     }
 
     override fun getType(): PsiType = _type
 
-    abstract override fun equals(other: Any?): Boolean
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is SymbolLightParameterCommon) return false
 
-    abstract override fun hashCode(): Int
+        if (parameterDeclaration != null) {
+            return parameterDeclaration == other.parameterDeclaration && ktModule == other.ktModule
+        }
+
+        return ktModule == other.ktModule && compareSymbolPointers(ktModule, parameterSymbolPointer, other.parameterSymbolPointer)
+    }
+
+    override fun hashCode(): Int = parameterDeclaration?.hashCode() ?: _name.hashCode()
+    override fun isValid(): Boolean = super.isValid() && parameterDeclaration?.isValid ?: parameterSymbolPointer.isValid(ktModule)
 }

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

@@ -7,60 +7,60 @@ package org.jetbrains.kotlin.light.classes.symbol.parameters
 
 import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiModifierList
-import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-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.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
+import org.jetbrains.kotlin.light.classes.symbol.classes.analyzeForLightClasses
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
+import org.jetbrains.kotlin.light.classes.symbol.restoreSymbolOrThrowIfDisposed
+import org.jetbrains.kotlin.light.classes.symbol.withSymbol
 import org.jetbrains.kotlin.name.SpecialNames
 
-context(KtAnalysisSession)
 internal class SymbolLightSetterParameter(
-    private val containingPropertySymbol: KtPropertySymbol,
+    private val containingPropertySymbolPointer: KtSymbolPointer<KtPropertySymbol>,
-    private val parameterSymbol: KtValueParameterSymbol,
+    parameterSymbol: KtValueParameterSymbol,
-    containingMethod: SymbolLightMethodBase
+    containingMethod: SymbolLightMethodBase,
 ) : SymbolLightParameterCommon(parameterSymbol, containingMethod) {
-
     override fun getName(): String {
-        if (containingPropertySymbol.setter?.isDefault != false)
+        if (isDefaultSetterParameter) return SpecialNames.IMPLICIT_SET_PARAMETER.asString()
-            return SpecialNames.IMPLICIT_SET_PARAMETER.asString()
         return super.getName()
     }
 
+    private val isDefaultSetterParameter: Boolean by lazy {
+        containingPropertySymbolPointer.withSymbol(ktModule) {
+            it.setter?.isDefault != false
+        }
+    }
+
     private val _annotations: List<PsiAnnotation> by lazyPub {
-        val annotationsFromSetter = parameterSymbol.computeAnnotations(
+        analyzeForLightClasses(ktModule) {
-            parent = this,
+            val annotationsFromSetter = parameterSymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
-            nullability = NullabilityType.Unknown,
+                parent = this@SymbolLightSetterParameter,
-            annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+                nullability = NullabilityType.Unknown,
-        )
+                annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+            )
 
-        val annotationsFromProperty = containingPropertySymbol.computeAnnotations(
+            val annotationsFromProperty = containingPropertySymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
-            parent = this,
+                parent = this@SymbolLightSetterParameter,
-            nullability = nullabilityType,
+                nullability = nullabilityType,
-            annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+                annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
-            includeAnnotationsWithoutSite = false
+                includeAnnotationsWithoutSite = false,
-        )
+            )
 
-        annotationsFromSetter + annotationsFromProperty
+            annotationsFromSetter + annotationsFromProperty
+        }
     }
 
     override fun getModifierList(): PsiModifierList = _modifierList
+
     private val _modifierList: PsiModifierList by lazyPub {
         SymbolLightClassModifierList(this, lazyOf(emptySet()), lazyOf(_annotations))
     }
 
     override fun isVarArgs() = false
-
-    override fun equals(other: Any?): Boolean =
-        this === other ||
-                (other is SymbolLightSetterParameter && parameterSymbol == other.parameterSymbol)
-
-    override fun hashCode(): Int = kotlinOrigin.hashCode()
-
-    override fun isValid(): Boolean = super.isValid() && parameterSymbol.isValid()
 }