[SLC] drop KtAnalysisSession from SymbolLightSimpleMethod

^KT-54051

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

@@ -8,12 +8,16 @@ package org.jetbrains.kotlin.light.classes.symbol.methods
 import com.intellij.psi.*
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtFunctionSymbol
+import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.light.classes.symbol.*
-import org.jetbrains.kotlin.light.classes.symbol.annotations.*
+import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
+import org.jetbrains.kotlin.light.classes.symbol.annotations.hasAnnotation
+import org.jetbrains.kotlin.light.classes.symbol.annotations.hasInlineOnlyAnnotation
+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.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightTypeParameterList
@@ -22,9 +26,8 @@ import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import java.util.*
 
-context(KtAnalysisSession)
 internal class SymbolLightSimpleMethod(
-    private val functionSymbol: KtFunctionSymbol,
+    functionSymbol: KtFunctionSymbol,
     lightMemberOrigin: LightMemberOrigin?,
     containingClass: SymbolLightClassBase,
     methodIndex: Int,
@@ -38,58 +41,50 @@ internal class SymbolLightSimpleMethod(
     methodIndex = methodIndex,
     argumentsSkipMask = argumentsSkipMask,
 ) {
-
     private val _name: String by lazyPub {
-        functionSymbol.computeJvmMethodName(functionSymbol.name.asString(), containingClass, annotationUseSiteTarget = null)
+        withFunctionSymbol { functionSymbol ->
+            functionSymbol.computeJvmMethodName(functionSymbol.name.asString(), containingClass, annotationUseSiteTarget = null)
+        }
     }
 
     override fun getName(): String = _name
 
     private val _typeParameterList: PsiTypeParameterList? by lazyPub {
         hasTypeParameters().ifTrue {
-            SymbolLightTypeParameterList(
+            withFunctionSymbol { functionSymbol ->
-                owner = this,
+                SymbolLightTypeParameterList(
-                symbolWithTypeParameterList = functionSymbol,
+                    owner = this@SymbolLightSimpleMethod,
-            )
+                    symbolWithTypeParameterList = functionSymbol,
+                )
+            }
         }
     }
 
-    override fun hasTypeParameters(): Boolean =
+    override fun hasTypeParameters(): Boolean = hasTypeParameters(ktModule, functionDeclaration, functionSymbolPointer)
-        functionSymbol.typeParameters.isNotEmpty()
 
     override fun getTypeParameterList(): PsiTypeParameterList? = _typeParameterList
-    override fun getTypeParameters(): Array<PsiTypeParameter> =
+    override fun getTypeParameters(): Array<PsiTypeParameter> = _typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY
-        _typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY
 
-    private fun computeAnnotations(isPrivate: Boolean): List<PsiAnnotation> {
+    context(KtAnalysisSession)
-        val nullability = if (isPrivate) {
+    private fun computeAnnotations(functionSymbol: KtFunctionSymbol, isPrivate: Boolean): List<PsiAnnotation> {
-            NullabilityType.Unknown
+        val nullability = when {
-        } else {
+            isPrivate -> NullabilityType.Unknown
-            run l@{
+            functionSymbol.isSuspend -> /* Any? */ NullabilityType.Nullable
-                val ktType =
+            else -> {
-                    when {
+                val returnType = functionSymbol.returnType
-                        functionSymbol.isSuspend -> // Any?
+                if (returnType.isVoidType) NullabilityType.Unknown else getTypeNullability(returnType)
-                            return@l NullabilityType.Nullable
-
-                        isVoidReturnType ->
-                            return@l NullabilityType.Unknown
-
-                        else ->
-                            functionSymbol.returnType
-                    }
-                getTypeNullability(ktType)
             }
         }
 
         return functionSymbol.computeAnnotations(
-            parent = this,
+            parent = this@SymbolLightSimpleMethod,
             nullability = nullability,
             annotationUseSiteTarget = null,
         )
     }
 
-    private fun computeModifiers(): Set<String> {
+    context(KtAnalysisSession)
-
+    private fun computeModifiers(functionSymbol: KtFunctionSymbol): Set<String> {
         if (functionSymbol.hasInlineOnlyAnnotation()) return setOf(PsiModifier.FINAL, PsiModifier.PRIVATE)
 
         val finalModifier = kotlinOrigin?.hasModifier(KtTokens.FINAL_KEYWORD) == true
@@ -123,36 +118,33 @@ internal class SymbolLightSimpleMethod(
     }
 
     private val _modifierList: PsiModifierList by lazyPub {
-        val modifiers = computeModifiers()
+        withFunctionSymbol { functionSymbol ->
-        val annotations = computeAnnotations(modifiers.contains(PsiModifier.PRIVATE))
+            val modifiers = computeModifiers(functionSymbol)
-        SymbolLightMemberModifierList(this, modifiers, annotations)
+            val annotations = computeAnnotations(functionSymbol, modifiers.contains(PsiModifier.PRIVATE))
+            SymbolLightMemberModifierList(this@SymbolLightSimpleMethod, modifiers, annotations)
+        }
     }
 
     override fun getModifierList(): PsiModifierList = _modifierList
 
     override fun isConstructor(): Boolean = false
 
-    private val isVoidReturnType: Boolean
+    private val KtType.isVoidType: Boolean get() = isUnit && nullabilityType != NullabilityType.Nullable
-        get() = functionSymbol.returnType.run {
-            isUnit && nullabilityType != NullabilityType.Nullable
-        }
 
     private val _returnedType: PsiType by lazyPub {
-        val ktType = when {
+        withFunctionSymbol { functionSymbol ->
-            functionSymbol.isSuspend -> // Any?
+            val ktType = if (functionSymbol.isSuspend) {
-                analysisSession.builtinTypes.NULLABLE_ANY
+                analysisSession.builtinTypes.NULLABLE_ANY // Any?
+            } else {
+                functionSymbol.returnType.takeUnless { it.isVoidType } ?: return@withFunctionSymbol PsiType.VOID
+            }
 
-            isVoidReturnType ->
+            ktType.asPsiType(
-                return@lazyPub PsiType.VOID
+                this@SymbolLightSimpleMethod,
-
+                KtTypeMappingMode.RETURN_TYPE,
-            else ->
+                containingClass.isAnnotationType,
-                functionSymbol.returnType
+            )
-        }
+        } ?: nonExistentType()
-        ktType.asPsiType(
-            this@SymbolLightSimpleMethod,
-            KtTypeMappingMode.RETURN_TYPE,
-            containingClass.isAnnotationType
-        ) ?: nonExistentType()
     }
 
     override fun getReturnType(): PsiType = _returnedType