[SLC] drop KtAnalysisSession from SymbolLightFieldForEnumEntry

^KT-54051

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

@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtEnumEntry
 import org.jetbrains.kotlin.resolve.DataClassResolver
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOriginKind
 import org.jetbrains.kotlin.util.OperatorNameConventions.EQUALS
@@ -287,7 +288,11 @@ internal open class SymbolLightClass(classOrObject: KtClassOrObject, ktModule: K
         if (isEnum) {
             classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols()
                 .filterIsInstance<KtEnumEntrySymbol>()
-                .mapTo(result) { SymbolLightFieldForEnumEntry(it, this@SymbolLightClass, null) }
+                .mapNotNullTo(result) {
+                    val enumEntry = it.psiSafe<KtEnumEntry>()
+                    val name = enumEntry?.name ?: return@mapNotNullTo null
+                    SymbolLightFieldForEnumEntry(enumEntry, name, this@SymbolLightClass, null)
+                }
         }
     }
 

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

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.light.classes.symbol.fields
 
 import com.intellij.psi.*
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
-import org.jetbrains.kotlin.analysis.api.lifetime.isValid
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.cannotModify
@@ -18,53 +17,59 @@ import org.jetbrains.kotlin.light.classes.symbol.SymbolLightIdentifier
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClass
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForEnumEntry
+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.nonExistentType
 import org.jetbrains.kotlin.psi.KtEnumEntry
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
-context(KtAnalysisSession)
 internal class SymbolLightFieldForEnumEntry(
-    private val enumEntrySymbol: KtEnumEntrySymbol,
+    private val enumEntry: KtEnumEntry,
+    private val enumEntryName: String,
     containingClass: SymbolLightClass,
     override val lightMemberOrigin: LightMemberOrigin?
 ) : SymbolLightField(containingClass, lightMemberOrigin), PsiEnumConstant {
+    private fun <T> withEnumEntrySymbol(action: KtAnalysisSession.(KtEnumEntrySymbol) -> T): T = analyzeForLightClasses(enumEntry) {
+        action(enumEntry.getEnumEntrySymbol())
+    }
 
     private val _modifierList by lazyPub {
         SymbolLightMemberModifierList(
             containingDeclaration = this@SymbolLightFieldForEnumEntry,
             modifiers = setOf(PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PUBLIC),
-            annotations = enumEntrySymbol.computeAnnotations(
+            annotations = withEnumEntrySymbol { enumEntrySymbol ->
-                this,
+                enumEntrySymbol.computeAnnotations(
-                nullability = NullabilityType.Unknown, // there is no need to add nullability annotations on enum entries
+                    this@SymbolLightFieldForEnumEntry,
-                annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD
+                    nullability = NullabilityType.Unknown, // there is no need to add nullability annotations on enum entries
-            )
+                    annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD
+                )
+            }
         )
     }
 
     override fun getModifierList(): PsiModifierList = _modifierList
 
-    override val kotlinOrigin: KtEnumEntry? = enumEntrySymbol.psi as? KtEnumEntry
+    override val kotlinOrigin: KtEnumEntry = enumEntry
 
     override fun isDeprecated(): Boolean = false
 
-    //TODO Make with KtSymbols
+    private val hasBody: Boolean get() = enumEntry.body != null
-    private val hasBody: Boolean get() = kotlinOrigin?.let { it.body != null } ?: true
 
     private val _initializingClass: PsiEnumConstantInitializer? by lazyPub {
         hasBody.ifTrue {
-            SymbolLightClassForEnumEntry(
+            withEnumEntrySymbol { enumEntrySymbol ->
-                enumEntrySymbol = enumEntrySymbol,
+                SymbolLightClassForEnumEntry(
-                enumConstant = this@SymbolLightFieldForEnumEntry,
+                    enumEntrySymbol = enumEntrySymbol,
-                enumClass = containingClass,
+                    enumConstant = this@SymbolLightFieldForEnumEntry,
-                ktModule = enumEntrySymbol.getContainingModule(),
+                    enumClass = containingClass,
-            )
+                    ktModule = enumEntrySymbol.getContainingModule(),
+                )
+            }
         }
     }
 
     override fun getInitializingClass(): PsiEnumConstantInitializer? = _initializingClass
-    override fun getOrCreateInitializingClass(): PsiEnumConstantInitializer =
+    override fun getOrCreateInitializingClass(): PsiEnumConstantInitializer = _initializingClass ?: cannotModify()
-        _initializingClass ?: cannotModify()
 
     override fun getArgumentList(): PsiExpressionList? = null
     override fun resolveMethod(): PsiMethod? = null
@@ -75,25 +80,28 @@ internal class SymbolLightFieldForEnumEntry(
     override fun hasInitializer() = true
     override fun computeConstantValue() = this
 
-    override fun getName(): String = enumEntrySymbol.name.asString()
+    override fun getName(): String = enumEntryName
 
     private val _type: PsiType by lazyPub {
-        enumEntrySymbol.returnType.asPsiType(this@SymbolLightFieldForEnumEntry) ?: nonExistentType()
+        withEnumEntrySymbol { enumEntrySymbol ->
+            enumEntrySymbol.returnType.asPsiType(this@SymbolLightFieldForEnumEntry) ?: nonExistentType()
+        }
     }
 
     override fun getType(): PsiType = _type
     override fun getInitializer(): PsiExpression? = null
 
-    override fun hashCode(): Int = enumEntrySymbol.hashCode()
-
     private val _identifier: PsiIdentifier by lazyPub {
-        SymbolLightIdentifier(this, enumEntrySymbol)
+        withEnumEntrySymbol { enumEntrySymbol ->
+            SymbolLightIdentifier(this@SymbolLightFieldForEnumEntry, enumEntrySymbol)
+        }
     }
 
     override fun getNameIdentifier(): PsiIdentifier = _identifier
 
-    override fun isValid(): Boolean = super.isValid() && enumEntrySymbol.isValid()
+    override fun isValid(): Boolean = enumEntry.isValid
 
+    override fun hashCode(): Int = enumEntry.hashCode()
 
-    override fun equals(other: Any?): Boolean = other is SymbolLightFieldForEnumEntry && enumEntrySymbol == other.enumEntrySymbol
+    override fun equals(other: Any?): Boolean = other is SymbolLightFieldForEnumEntry && enumEntry == other.enumEntry
 }