[SLC] migrate SymbolLightModifierList to ModifiersBox and AnnotationsBox

LazyAnnotationsBox is unused now Will be migrated to it in the next steps ^KT-56046
2023-01-25 12:35:30 +01:00
parent cdb7d8116f
commit 6d0570739d
19 changed files with 173 additions and 192 deletions
@@ -26,10 +26,12 @@ import org.jetbrains.kotlin.builtins.StandardNames.HASHCODE_NAME
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForEnumEntry
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForObject
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightSimpleMethod
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.LazyModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.name.Name
@@ -83,11 +85,11 @@ internal open class SymbolLightClassForClassOrObject : SymbolLightClassForNamedC
        manager = manager,
    )

-    private val _modifierList: PsiModifierList? by lazyPub {
+    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            lazyModifiersComputer = ::computeModifiers,
-            annotationsComputer = { modifierList ->
+            modifiersBox = LazyModifiersBox(computer = ::computeModifiers),
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
                withClassOrObjectSymbol { classOrObjectSymbol ->
                    classOrObjectSymbol.computeAnnotations(
                        modifierList = modifierList,
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMethod
 import org.jetbrains.kotlin.light.classes.symbol.codeReferences.SymbolLightPsiJavaCodeReferenceElementWithNoReference
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForEnumEntry
 import org.jetbrains.kotlin.light.classes.symbol.isOriginEquivalentTo
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SimpleModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
 import org.jetbrains.kotlin.psi.KtEnumEntry
@@ -52,8 +53,7 @@ internal class SymbolLightClassForEnumEntry(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            staticModifiers = setOf(PsiModifier.STATIC, PsiModifier.FINAL),
-            annotationsComputer = null,
+            modifiersBox = SimpleModifiersBox(PsiModifier.STATIC, PsiModifier.FINAL),
        )
    }

@@ -27,10 +27,12 @@ import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.analyzeForLightClasses
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasInlineOnlyAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SimpleModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForMember
 import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind
@@ -64,23 +66,24 @@ class SymbolLightClassForFacade(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            staticModifiers = setOf(PsiModifier.PUBLIC, PsiModifier.FINAL),
-        ) { modifierList ->
-            if (multiFileClass) {
-                emptyList()
-            } else {
-                withFileSymbols { fileSymbols ->
-                    fileSymbols.flatMap {
-                        it.computeAnnotations(
-                            modifierList = modifierList,
-                            nullability = NullabilityType.Unknown,
-                            annotationUseSiteTarget = AnnotationUseSiteTarget.FILE,
-                            includeAnnotationsWithoutSite = false,
-                        )
+            modifiersBox = SimpleModifiersBox(PsiModifier.PUBLIC, PsiModifier.FINAL),
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                if (multiFileClass) {
+                    emptyList()
+                } else {
+                    withFileSymbols { fileSymbols ->
+                        fileSymbols.flatMap {
+                            it.computeAnnotations(
+                                modifierList = modifierList,
+                                nullability = NullabilityType.Unknown,
+                                annotationUseSiteTarget = AnnotationUseSiteTarget.FILE,
+                                includeAnnotationsWithoutSite = false,
+                            )
+                        }
                    }
                }
-            }
-        }
+            },
+        )
    }

    override fun getModifierList(): PsiModifierList = _modifierList
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.light.classes.symbol.classes

 import com.intellij.psi.*
 import com.intellij.util.IncorrectOperationException
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SimpleModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.JvmAbi

@@ -38,8 +39,7 @@ internal class SymbolLightClassForInterfaceDefaultImpls(private val containingCl

    override fun computeModifierList(): PsiModifierList = SymbolLightClassModifierList(
        containingDeclaration = this,
-        staticModifiers = setOf(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL),
-        annotationsComputer = null,
+        modifiersBox = SimpleModifiersBox(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.FINAL),
    )

    override fun isInterface(): Boolean = false
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.LazyModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
@@ -67,17 +68,20 @@ internal abstract class SymbolLightClassForInterfaceOrAnnotationClass : SymbolLi

    protected open fun computeModifierList(): PsiModifierList? = SymbolLightClassModifierList(
        containingDeclaration = this,
-        initialValue = LazyModifiersBox.MODALITY_MODIFIERS_MAP.with(PsiModifier.ABSTRACT),
-        lazyModifiersComputer = ::computeModifiers
-    ) { modifierList ->
-        withClassOrObjectSymbol { classOrObjectSymbol ->
-            classOrObjectSymbol.computeAnnotations(
-                modifierList = modifierList,
-                nullability = NullabilityType.Unknown,
-                annotationUseSiteTarget = null,
-            )
-        }
-    }
+        modifiersBox = LazyModifiersBox(
+            initialValue = LazyModifiersBox.MODALITY_MODIFIERS_MAP.with(PsiModifier.ABSTRACT),
+            computer = ::computeModifiers
+        ),
+        annotationsBox = SimpleAnnotationsBox { modifierList ->
+            withClassOrObjectSymbol { classOrObjectSymbol ->
+                classOrObjectSymbol.computeAnnotations(
+                    modifierList = modifierList,
+                    nullability = NullabilityType.Unknown,
+                    annotationUseSiteTarget = null,
+                )
+            }
+        },
+    )

    private val _modifierList: PsiModifierList? by lazyPub {
        computeModifierList()
@@ -11,9 +11,11 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.elements.KtLightField
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightSimpleAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightRepeatableAnnotationContainerMethod
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SimpleModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.load.java.JvmAbi

@@ -39,9 +41,9 @@ internal class SymbolLightClassForRepeatableAnnotationContainer(private val cont
    override fun computeModifierList(): PsiModifierList = SymbolLightClassModifierList(
        containingDeclaration = this,
        // It is marked as Abstract because all the annotation classes are marked as Abstract
-        // It is marked as Static because all nested interfaces marked as Static
-        staticModifiers = setOf(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.ABSTRACT),
-        annotationsComputer = { psiModifierList ->
+        // It is marked as Static because all nested interfaces are marked as Static
+        modifiersBox = SimpleModifiersBox(PsiModifier.PUBLIC, PsiModifier.STATIC, PsiModifier.ABSTRACT),
+        annotationsBox = SimpleAnnotationsBox { psiModifierList ->
            val annotations = withClassOrObjectSymbol { classOrObjectSymbol ->
                classOrObjectSymbol.computeAnnotations(
                    modifierList = psiModifierList,
@@ -13,10 +13,12 @@ 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.analyzeForLightClasses
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForClassOrObject
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForEnumEntry
 import org.jetbrains.kotlin.light.classes.symbol.isOriginEquivalentTo
+import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SimpleModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.psi.KtEnumEntry
@@ -35,16 +37,17 @@ internal class SymbolLightFieldForEnumEntry(
    private val _modifierList by lazyPub {
        SymbolLightMemberModifierList(
            containingDeclaration = this,
-            staticModifiers = setOf(PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PUBLIC),
-        ) { modifierList ->
-            withEnumEntrySymbol { enumEntrySymbol ->
-                enumEntrySymbol.computeAnnotations(
-                    modifierList,
-                    nullability = NullabilityType.Unknown, // there is no need to add nullability annotations on enum entries
-                    annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD,
-                )
-            }
-        }
+            modifiersBox = SimpleModifiersBox(PsiModifier.STATIC, PsiModifier.FINAL, PsiModifier.PUBLIC),
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                withEnumEntrySymbol { enumEntrySymbol ->
+                    enumEntrySymbol.computeAnnotations(
+                        modifierList,
+                        nullability = NullabilityType.Unknown, // there is no need to add nullability annotations on enum entries
+                        annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD,
+                    )
+                }
+            },
+        )
    }

    override fun isEquivalentTo(another: PsiElement?): Boolean {
@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.symbols.sourcePsiSafe
 import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightSimpleAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForClassLike
@@ -57,14 +58,17 @@ internal class SymbolLightFieldForObject private constructor(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightMemberModifierList(
            containingDeclaration = this,
-            initialValue = LazyModifiersBox.MODALITY_MODIFIERS_MAP.mutate {
-                it[PsiModifier.FINAL] = true
-                it[PsiModifier.STATIC] = true
+            modifiersBox = LazyModifiersBox(
+                initialValue = LazyModifiersBox.MODALITY_MODIFIERS_MAP.mutate {
+                    it[PsiModifier.FINAL] = true
+                    it[PsiModifier.STATIC] = true
+                },
+                computer = ::computeModifiers,
+            ),
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                listOf(SymbolLightSimpleAnnotation(NotNull::class.java.name, modifierList))
            },
-            lazyModifiersComputer = ::computeModifiers,
-        ) { modifierList ->
-            listOf(SymbolLightSimpleAnnotation(NotNull::class.java.name, modifierList))
-        }
+        )
    }

    private fun computeModifiers(modifier: String): Map<String, Boolean>? {
@@ -204,8 +204,8 @@ internal class SymbolLightAccessorMethod private constructor(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightMemberModifierList(
            containingDeclaration = this,
-            lazyModifiersComputer = ::computeModifiers,
-            annotationsComputer = ::computeAnnotations,
+            modifiersBox = LazyModifiersBox(computer = ::computeModifiers),
+            annotationsBox = SimpleAnnotationsBox(::computeAnnotations),
        )
    }

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeAnnotations
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForEnumEntry
@@ -52,17 +53,20 @@ internal class SymbolLightConstructor(

        SymbolLightMemberModifierList(
            containingDeclaration = this,
-            initialValue = initialValue,
-            lazyModifiersComputer = ::computeModifiers,
-        ) { modifierList ->
-            withFunctionSymbol { constructorSymbol ->
-                constructorSymbol.computeAnnotations(
-                    modifierList = modifierList,
-                    nullability = NullabilityType.Unknown,
-                    annotationUseSiteTarget = null,
-                )
-            }
-        }
+            modifiersBox = LazyModifiersBox(
+                initialValue = initialValue,
+                computer = ::computeModifiers,
+            ),
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                withFunctionSymbol { constructorSymbol ->
+                    constructorSymbol.computeAnnotations(
+                        modifierList = modifierList,
+                        nullability = NullabilityType.Unknown,
+                        annotationUseSiteTarget = null,
+                    )
+                }
+            },
+        )
    }

    private fun computeModifiers(modifier: String): Map<String, Boolean>? {
@@ -22,7 +22,7 @@ import java.util.concurrent.atomic.AtomicReference
 internal typealias LazyModifiersComputer = (modifier: String) -> Map<String, Boolean>?

 internal class LazyModifiersBox(
-    initialValue: Map<String, Boolean>,
+    initialValue: Map<String, Boolean> = emptyMap(),
    private val computer: LazyModifiersComputer,
 ) : ModifiersBox {
    private val modifiersMapReference: AtomicReference<PersistentMap<String, Boolean>> = AtomicReference(initialValue.toPersistentHashMap())
@@ -6,5 +6,6 @@
 package org.jetbrains.kotlin.light.classes.symbol.modifierLists

 internal class SimpleModifiersBox(private val modifiers: Set<String>) : ModifiersBox {
+    constructor(vararg modifiers: String) : this(modifiers.toSet())
    override fun hasModifier(modifier: String): Boolean = modifier in modifiers
 }
@@ -5,23 +5,14 @@

 package org.jetbrains.kotlin.light.classes.symbol.modifierLists

-import com.intellij.psi.PsiAnnotation
-import com.intellij.psi.PsiModifierList
 import com.intellij.psi.PsiModifierListOwner
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
+import org.jetbrains.kotlin.light.classes.symbol.annotations.AnnotationsBox
+import org.jetbrains.kotlin.light.classes.symbol.annotations.EmptyAnnotationsBox
 import org.jetbrains.kotlin.psi.KtModifierListOwner

-internal class SymbolLightClassModifierList<T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>> : SymbolLightModifierList<T> {
-    constructor(
-        containingDeclaration: T,
-        initialValue: Map<String, Boolean> = emptyMap(),
-        lazyModifiersComputer: LazyModifiersComputer,
-        annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
-    ) : super(containingDeclaration, initialValue, lazyModifiersComputer, annotationsComputer)
-
-    constructor(
-        containingDeclaration: T,
-        staticModifiers: Set<String>,
-        annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
-    ) : super(containingDeclaration, staticModifiers, annotationsComputer)
-}
+internal class SymbolLightClassModifierList<T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(
+    containingDeclaration: T,
+    modifiersBox: ModifiersBox = EmptyModifiersBox,
+    annotationsBox: AnnotationsBox = EmptyAnnotationsBox,
+) : SymbolLightModifierList<T>(containingDeclaration, modifiersBox, annotationsBox)
@@ -6,29 +6,20 @@
 package org.jetbrains.kotlin.light.classes.symbol.modifierLists

 import com.intellij.openapi.util.TextRange
-import com.intellij.psi.PsiAnnotation
 import com.intellij.psi.PsiModifier
-import com.intellij.psi.PsiModifierList
 import org.jetbrains.kotlin.asJava.elements.KtLightMember
+import org.jetbrains.kotlin.light.classes.symbol.annotations.AnnotationsBox
+import org.jetbrains.kotlin.light.classes.symbol.annotations.EmptyAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtPropertyAccessor
 import org.jetbrains.kotlin.psi.psiUtil.hasBody

-internal class SymbolLightMemberModifierList<T : KtLightMember<*>> : SymbolLightModifierList<T> {
-    constructor(
-        containingDeclaration: T,
-        initialValue: Map<String, Boolean> = emptyMap(),
-        lazyModifiersComputer: LazyModifiersComputer,
-        annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
-    ) : super(containingDeclaration, initialValue, lazyModifiersComputer, annotationsComputer)
-
-    constructor(
-        containingDeclaration: T,
-        staticModifiers: Set<String>,
-        annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
-    ) : super(containingDeclaration, staticModifiers, annotationsComputer)
-
+internal class SymbolLightMemberModifierList<T : KtLightMember<*>>(
+    containingDeclaration: T,
+    modifiersBox: ModifiersBox = EmptyModifiersBox,
+    annotationsBox: AnnotationsBox = EmptyAnnotationsBox,
+) : SymbolLightModifierList<T>(containingDeclaration, modifiersBox, annotationsBox) {
    override fun hasModifierProperty(name: String): Boolean = when {
        name == PsiModifier.ABSTRACT && isImplementationInInterface() -> false
        // Pretend this method behaves like a `default` method
@@ -8,46 +8,21 @@ package org.jetbrains.kotlin.light.classes.symbol.modifierLists
 import com.intellij.psi.*
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.asJava.classes.cannotModify
-import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.asJava.elements.KtLightAbstractAnnotation
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
+import org.jetbrains.kotlin.light.classes.symbol.annotations.AnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.invalidAccess
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtModifierListOwner

-internal sealed class SymbolLightModifierList<out T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>> :
-    KtLightElementBase, PsiModifierList, KtLightElement<KtModifierList, PsiModifierListOwner> {
-    protected val owner: T
-    private val staticModifiers: Set<String>?
-    private val lazyModifiersBox: LazyModifiersBox?
-    private val lazyAnnotations: Lazy<List<PsiAnnotation>>?
-
-    constructor(
-        owner: T,
-        initialValue: Map<String, Boolean>,
-        lazyModifiersComputer: LazyModifiersComputer,
-        annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
-    ) : super(owner) {
-        this.owner = owner
-        this.lazyAnnotations = annotationsComputer?.let { lazyPub { annotationsComputer(this) } }
-
-        this.lazyModifiersBox = LazyModifiersBox(initialValue, lazyModifiersComputer)
-        this.staticModifiers = null
-    }
-
-    constructor(
-        owner: T,
-        staticModifiers: Set<String>,
-        annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
-    ) : super(owner) {
-        this.owner = owner
-        this.lazyAnnotations = annotationsComputer?.let { lazyPub { annotationsComputer(this) } }
-
-        this.lazyModifiersBox = null
-        this.staticModifiers = staticModifiers
-    }
-
+internal sealed class SymbolLightModifierList<out T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>>(
+    protected val owner: T,
+    private val modifiersBox: ModifiersBox,
+    private val annotationsBox: AnnotationsBox,
+) : KtLightElementBase(owner),
+    PsiModifierList,
+    KtLightElement<KtModifierList, PsiModifierListOwner> {
    override fun accept(visitor: PsiElementVisitor) {
        if (visitor is JavaElementVisitor) {
            visitor.visitModifierList(this)
@@ -58,25 +33,22 @@ internal sealed class SymbolLightModifierList<out T : KtLightElement<KtModifierL

    override val kotlinOrigin: KtModifierList? get() = owner.kotlinOrigin?.modifierList
    override fun getParent() = owner
-    override fun setModifierProperty(name: String, value: Boolean) = cannotModify()
-    override fun checkSetModifierProperty(name: String, value: Boolean) = throw IncorrectOperationException()
-    override fun addAnnotation(qualifiedName: String): PsiAnnotation = cannotModify()
-    override fun getApplicableAnnotations(): Array<out PsiAnnotation> = annotations
    override fun isEquivalentTo(another: PsiElement?) = another is SymbolLightModifierList<*> && owner == another.owner
    override fun isWritable() = false
    override fun toString() = "Light modifier list of $owner"
-
    override val givenAnnotations: List<KtLightAbstractAnnotation> get() = invalidAccess()

-    override fun getAnnotations(): Array<out PsiAnnotation> = lazyAnnotations?.value?.toTypedArray() ?: PsiAnnotation.EMPTY_ARRAY
-    override fun findAnnotation(qualifiedName: String): PsiAnnotation? =
-        lazyAnnotations?.value?.firstOrNull { it.qualifiedName == qualifiedName }
-
    override fun equals(other: Any?): Boolean = this === other || other is SymbolLightModifierList<*> && other.kotlinOrigin == kotlinOrigin
-
    override fun hashCode(): Int = kotlinOrigin.hashCode()

+    override fun setModifierProperty(name: String, value: Boolean) = cannotModify()
+    override fun checkSetModifierProperty(name: String, value: Boolean) = throw IncorrectOperationException()
    override fun hasExplicitModifier(name: String) = hasModifierProperty(name)
-    override fun hasModifierProperty(name: String): Boolean =
-        staticModifiers?.contains(name) == true || lazyModifiersBox?.hasModifier(name) == true
+    override fun hasModifierProperty(name: String): Boolean = modifiersBox.hasModifier(name)
+
+    override fun getAnnotations(): Array<PsiAnnotation> = annotationsBox.annotations(this)
+    override fun getApplicableAnnotations(): Array<PsiAnnotation> = annotations
+    override fun findAnnotation(qualifiedName: String): PsiAnnotation? = annotationsBox.findAnnotation(this, qualifiedName)
+    override fun hasAnnotation(qualifiedName: String): Boolean = annotationsBox.hasAnnotation(this, qualifiedName)
+    override fun addAnnotation(qualifiedName: String): PsiAnnotation = throw UnsupportedOperationException()
 }
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtValueParameterSymbol
 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.SimpleAnnotationsBox
 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
@@ -29,22 +30,22 @@ internal class SymbolLightParameter(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            staticModifiers = emptySet(),
-        ) { modifierList ->
-            val annotationSite = isConstructorParameterSymbol.ifTrue {
-                AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER
-            }
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                val annotationSite = isConstructorParameterSymbol.ifTrue {
+                    AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER
+                }

-            parameterSymbolPointer.withSymbol(ktModule) { parameterSymbol ->
-                val nullability = if (parameterSymbol.isVararg) NullabilityType.NotNull else super.nullabilityType
-                parameterSymbol.computeAnnotations(
-                    modifierList = modifierList,
-                    nullability = nullability,
-                    annotationUseSiteTarget = annotationSite,
-                    includeAnnotationsWithoutSite = true,
-                )
-            }
-        }
+                parameterSymbolPointer.withSymbol(ktModule) { parameterSymbol ->
+                    val nullability = if (parameterSymbol.isVararg) NullabilityType.NotNull else super.nullabilityType
+                    parameterSymbol.computeAnnotations(
+                        modifierList = modifierList,
+                        nullability = nullability,
+                        annotationUseSiteTarget = annotationSite,
+                        includeAnnotationsWithoutSite = true,
+                    )
+                }
+            },
+        )
    }

    private val isVararg: Boolean by lazyPub {
@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.light.classes.symbol.*
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightAnnotationForAnnotationCall
 import org.jetbrains.kotlin.light.classes.symbol.annotations.computeNullabilityAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
@@ -70,17 +71,17 @@ internal class SymbolLightParameterForReceiver private constructor(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            staticModifiers = emptySet(),
-        ) { modifierList ->
-            withReceiverSymbol { receiver ->
-                buildList {
-                    receiver.type.nullabilityType.computeNullabilityAnnotation(modifierList)?.let(::add)
-                    receiver.annotations.mapTo(this) {
-                        SymbolLightAnnotationForAnnotationCall(it, modifierList)
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                withReceiverSymbol { receiver ->
+                    buildList {
+                        receiver.type.nullabilityType.computeNullabilityAnnotation(modifierList)?.let(::add)
+                        receiver.annotations.mapTo(this) {
+                            SymbolLightAnnotationForAnnotationCall(it, modifierList)
+                        }
                    }
                }
-            }
-        }
+            },
+        )
    }

    private val _type: PsiType by lazyPub {
@@ -14,6 +14,7 @@ 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.analyzeForLightClasses
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 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
@@ -43,25 +44,25 @@ internal class SymbolLightSetterParameter(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            staticModifiers = emptySet(),
-        ) { modifierList ->
-            analyzeForLightClasses(ktModule) {
-                val annotationsFromSetter = parameterSymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
-                    modifierList = modifierList,
-                    nullability = NullabilityType.Unknown,
-                    annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
-                )
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                analyzeForLightClasses(ktModule) {
+                    val annotationsFromSetter = parameterSymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
+                        modifierList = modifierList,
+                        nullability = NullabilityType.Unknown,
+                        annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+                    )

-                val annotationsFromProperty = containingPropertySymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
-                    modifierList = modifierList,
-                    nullability = nullabilityType,
-                    annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
-                    includeAnnotationsWithoutSite = false,
-                )
+                    val annotationsFromProperty = containingPropertySymbolPointer.restoreSymbolOrThrowIfDisposed().computeAnnotations(
+                        modifierList = modifierList,
+                        nullability = nullabilityType,
+                        annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+                        includeAnnotationsWithoutSite = false,
+                    )

-                annotationsFromSetter + annotationsFromProperty
-            }
-        }
+                    annotationsFromSetter + annotationsFromProperty
+                }
+            },
+        )
    }

    override fun isVarArgs() = false
@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.isPrivateOrPrivateToThi
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.codegen.coroutines.SUSPEND_FUNCTION_COMPLETION_PARAMETER_NAME
+import org.jetbrains.kotlin.light.classes.symbol.annotations.SimpleAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolLightSimpleAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.isValid
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
@@ -54,13 +55,13 @@ internal class SymbolLightSuspendContinuationParameter(
    private val _modifierList: PsiModifierList by lazyPub {
        SymbolLightClassModifierList(
            containingDeclaration = this,
-            staticModifiers = emptySet(),
-        ) { modifierList ->
-            if (withFunctionSymbol { it.visibility.isPrivateOrPrivateToThis() })
-                emptyList()
-            else
-                listOf(SymbolLightSimpleAnnotation(NotNull::class.java.name, modifierList))
-        }
+            annotationsBox = SimpleAnnotationsBox { modifierList ->
+                if (withFunctionSymbol { it.visibility.isPrivateOrPrivateToThis() })
+                    emptyList()
+                else
+                    listOf(SymbolLightSimpleAnnotation(NotNull::class.java.name, modifierList))
+            },
+        )
    }

    override fun hasModifierProperty(p0: String): Boolean = false