From 4f48bf6643009bc41d7e67ba64a084a4063e00d0 Mon Sep 17 00:00:00 2001 From: Dmitrii Gridin Date: Thu, 17 Nov 2022 15:13:54 +0100 Subject: [PATCH] [SLC] drop KtAnalysisSession from SymbolLightParameterCommon ^KT-54051 --- .../methods/SymbolLightAccessorMethod.kt | 2 +- .../symbol/parameters/SymbolLightParameter.kt | 36 ++++---- .../parameters/SymbolLightParameterCommon.kt | 91 ++++++++++++------- .../parameters/SymbolLightSetterParameter.kt | 58 ++++++------ 4 files changed, 103 insertions(+), 84 deletions(-) diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightAccessorMethod.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightAccessorMethod.kt index d551714e9db..6c394b7af72 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightAccessorMethod.kt +++ b/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 ) ) } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameter.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameter.kt index 588b4bfa74c..a6f9b497aea 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameter.kt +++ b/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 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 } \ No newline at end of file diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt index aeefc1024fa..dfab5af0d2e 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightParameterCommon.kt +++ b/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.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 = 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) } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightSetterParameter.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightSetterParameter.kt index 19f3da2062e..8be448c3950 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/parameters/SymbolLightSetterParameter.kt +++ b/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 parameterSymbol: KtValueParameterSymbol, - containingMethod: SymbolLightMethodBase + private val containingPropertySymbolPointer: KtSymbolPointer, + 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 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() }