[SLC] drop KtAnalysisSession from SymbolLightParameterCommon

^KT-54051
2022-11-17 15:13:54 +01:00
parent 37729c0353
commit 4f48bf6643
4 changed files with 103 additions and 84 deletions
@@ -227,7 +227,7 @@ internal class SymbolLightAccessorMethod(
                    if (propertyParameter != null) {
                        builder.addParameter(
                            SymbolLightSetterParameter(
-                                propertySymbol(), propertyParameter, this@SymbolLightAccessorMethod
+                                containingPropertySymbolPointer, propertyParameter, this@SymbolLightAccessorMethod
                            )
                        )
                    }
@@ -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(
-            parent = this,
-            nullability = nullability,
-            annotationUseSiteTarget = annotationSite,
-            includeAnnotationsWithoutSite = true
-        )
+            parameterSymbol.computeAnnotations(
+                parent = this,
+                nullability = nullability,
+                annotationUseSiteTarget = annotationSite,
+                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 =
-        this === other ||
-                (other is SymbolLightParameter && parameterSymbol == other.parameterSymbol)
-
-    override fun hashCode(): Int = kotlinOrigin.hashCode()
-
-    override fun isValid(): Boolean = super.isValid() && parameterSymbol.isValid()
+    override fun isVarArgs() = isVararg
 }
@@ -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.light.classes.symbol.SymbolLightIdentifier
-import org.jetbrains.kotlin.light.classes.symbol.getTypeNullability
+import org.jetbrains.kotlin.asJava.elements.KtLightIdentifier
+import org.jetbrains.kotlin.light.classes.symbol.*
 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 =
-        modifierList.hasModifierProperty(name)
+    override fun hasModifierProperty(name: String): Boolean = 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 {
-        SymbolLightIdentifier(this, parameterSymbol)
+    private val _identifier: PsiIdentifier by lazy {
+        KtLightIdentifier(this, parameterDeclaration)
    }

-    protected val nullabilityType: NullabilityType
-        get() {
-            val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } &&
-                    !containingMethod.hasModifierProperty(PsiModifier.PRIVATE)
+    protected val nullabilityType: NullabilityType by lazyPub {
+        val nullabilityApplicable = !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) &&
+                !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum }

-            return if (nullabilityApplicable) getTypeNullability(parameterSymbol.returnType)
-            else NullabilityType.Unknown
+        if (nullabilityApplicable) {
+            parameterSymbolPointer.withSymbol(ktModule) { getTypeNullability(it.returnType) }
+        } else {
+            NullabilityType.Unknown
        }
+    }

    override fun getNameIdentifier(): PsiIdentifier = _identifier

-    private val _type by lazyPub {
-        val convertedType = run {
-            val ktType = parameterSymbol.returnType
-            val typeMappingMode = when {
-                ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT
-                // TODO: extract type mapping mode from annotation?
-                // TODO: methods with declaration site wildcards?
-                else -> KtTypeMappingMode.VALUE_PARAMETER
+    private val _type by lazy {
+        parameterSymbolPointer.withSymbol(ktModule) { parameterSymbol ->
+            val convertedType = run {
+                val ktType = parameterSymbol.returnType
+                val typeMappingMode = when {
+                    ktType.isSuspendFunctionType -> KtTypeMappingMode.DEFAULT
+                    // TODO: extract type mapping mode from annotation?
+                    // 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)
 }
@@ -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 parameterSymbol: KtValueParameterSymbol,
-    containingMethod: SymbolLightMethodBase
+    private val containingPropertySymbolPointer: KtSymbolPointer<KtPropertySymbol>,
+    parameterSymbol: KtValueParameterSymbol,
+    containingMethod: SymbolLightMethodBase,
 ) : SymbolLightParameterCommon(parameterSymbol, containingMethod) {
-
    override fun getName(): String {
-        if (containingPropertySymbol.setter?.isDefault != false)
-            return SpecialNames.IMPLICIT_SET_PARAMETER.asString()
+        if (isDefaultSetterParameter) 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(
-            parent = this,
-            nullability = NullabilityType.Unknown,
-            annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
-        )
+        analyzeForLightClasses(ktModule) {
+            val annotationsFromSetter = parameterSymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
+                parent = this@SymbolLightSetterParameter,
+                nullability = NullabilityType.Unknown,
+                annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+            )

-        val annotationsFromProperty = containingPropertySymbol.computeAnnotations(
-            parent = this,
-            nullability = nullabilityType,
-            annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
-            includeAnnotationsWithoutSite = false
-        )
+            val annotationsFromProperty = containingPropertySymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
+                parent = this@SymbolLightSetterParameter,
+                nullability = nullabilityType,
+                annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+                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()
 }