[AA] introduce AnnotationUseSiteTargetFilter to simplify API

^KT-56046
2023-01-27 21:05:51 +01:00
parent 6e25b45f7d
commit 93232a23df
31 changed files with 325 additions and 249 deletions
@@ -11,40 +11,35 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotatedSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.withSymbol
 import org.jetbrains.kotlin.name.ClassId

 internal class SymbolAnnotationsProvider<T : KtAnnotatedSymbol>(
    private val ktModule: KtModule,
    private val annotatedSymbolPointer: KtSymbolPointer<T>,
-    private val annotationUseSiteTarget: AnnotationUseSiteTarget? = null,
-    private val acceptAnnotationsWithoutSite: Boolean = false,
+    private val annotationUseSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
 ) : AnnotationsProvider {
    private inline fun <T> withAnnotatedSymbol(crossinline action: context(KtAnalysisSession) (KtAnnotatedSymbol) -> T): T =
        annotatedSymbolPointer.withSymbol(ktModule, action)

    override fun annotationInfos(): List<KtAnnotationApplicationInfo> = withAnnotatedSymbol { annotatedSymbol ->
        annotatedSymbol.annotationInfos.filter {
-            it.useSiteTarget == annotationUseSiteTarget || acceptAnnotationsWithoutSite && it.useSiteTarget == null
+            annotationUseSiteTargetFilter.isAllowed(it.useSiteTarget)
        }
    }

    override fun get(classId: ClassId): Collection<KtAnnotationApplicationWithArgumentsInfo> = withAnnotatedSymbol { annotatedSymbol ->
-        annotatedSymbol.annotationsByClassId(classId).filter {
-            it.useSiteTarget == annotationUseSiteTarget || acceptAnnotationsWithoutSite && it.useSiteTarget == null
-        }
+        annotatedSymbol.annotationsByClassId(classId, annotationUseSiteTargetFilter)
    }

    override fun contains(classId: ClassId): Boolean = withAnnotatedSymbol { annotatedSymbol ->
-        annotatedSymbol.hasAnnotation(classId, annotationUseSiteTarget, acceptAnnotationsWithoutSite)
+        annotatedSymbol.hasAnnotation(classId, annotationUseSiteTargetFilter)
    }

    override fun isTheSameAs(other: Any?): Boolean = other === this ||
            other is SymbolAnnotationsProvider<*> &&
            other.ktModule == ktModule &&
-            other.annotationUseSiteTarget == annotationUseSiteTarget &&
-            other.acceptAnnotationsWithoutSite == acceptAnnotationsWithoutSite &&
+            other.annotationUseSiteTargetFilter == annotationUseSiteTargetFilter &&
            annotatedSymbolPointer.pointsToTheSameSymbolAs(other.annotatedSymbolPointer)

    override fun ownerClassId(): ClassId? = withAnnotatedSymbol { annotatedSymbol ->
@@ -24,13 +24,26 @@ import org.jetbrains.kotlin.name.JvmNames.JVM_SYNTHETIC_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.resolve.deprecation.DeprecationLevelValue

-internal fun KtAnnotatedSymbol.hasJvmSyntheticAnnotation(
-    annotationUseSiteTarget: AnnotationUseSiteTarget? = null,
-    acceptAnnotationsWithoutUseSite: Boolean = false,
-): Boolean = hasAnnotation(JVM_SYNTHETIC_ANNOTATION_CLASS_ID, annotationUseSiteTarget, acceptAnnotationsWithoutUseSite)
+internal fun AnnotationUseSiteTarget?.toFilterWithAdditionalNull(): AnnotationUseSiteTargetFilter {
+    if (this == null) return NullAnnotationUseSiteTargetFilter

-internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): String? {
-    val annotation = findAnnotation(StandardClassIds.Annotations.JvmName, annotationUseSiteTarget, acceptAnnotationsWithoutUseSite = true)
+    return annotationUseSiteTargetFilterOf(NullAnnotationUseSiteTargetFilter, toFilter())
+}
+
+internal fun annotationUseSiteTargetFilterOf(
+    vararg filters: AnnotationUseSiteTargetFilter,
+): AnnotationUseSiteTargetFilter = AnnotationUseSiteTargetFilter { useSiteTarget ->
+    filters.any { filter -> filter.isAllowed(useSiteTarget) }
+}
+
+internal fun KtAnnotatedSymbol.hasJvmSyntheticAnnotation(
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
+): Boolean = hasAnnotation(JVM_SYNTHETIC_ANNOTATION_CLASS_ID, useSiteTargetFilter)
+
+internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
+): String? {
+    val annotation = findAnnotation(StandardClassIds.Annotations.JvmName, useSiteTargetFilter)
    return annotation?.let {
        (it.arguments.firstOrNull()?.expression as? KtConstantAnnotationValue)?.constantValue?.value as? String
    }
@@ -45,56 +58,49 @@ internal fun isHiddenByDeprecation(
 context(KtAnalysisSession)
 internal fun KtAnnotatedSymbol.isHiddenOrSynthetic(
    annotationUseSiteTarget: AnnotationUseSiteTarget? = null,
-    acceptAnnotationsWithoutUseSite: Boolean = false,
-) = isHiddenByDeprecation(this, annotationUseSiteTarget) ||
-        hasJvmSyntheticAnnotation(annotationUseSiteTarget, acceptAnnotationsWithoutUseSite)
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = annotationUseSiteTarget.toFilter(),
+) = isHiddenByDeprecation(this, annotationUseSiteTarget) || hasJvmSyntheticAnnotation(useSiteTargetFilter)

 internal fun KtAnnotatedSymbol.hasJvmFieldAnnotation(): Boolean = hasAnnotation(StandardClassIds.Annotations.JvmField)

-internal fun KtAnnotatedSymbol.hasPublishedApiAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): Boolean =
-    hasAnnotation(StandardClassIds.Annotations.PublishedApi, annotationUseSiteTarget)
+internal fun KtAnnotatedSymbol.hasPublishedApiAnnotation(
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
+): Boolean = hasAnnotation(StandardClassIds.Annotations.PublishedApi, useSiteTargetFilter)

 internal fun KtAnnotatedSymbol.hasDeprecatedAnnotation(
-    annotationUseSiteTarget: AnnotationUseSiteTarget? = null,
-    acceptAnnotationsWithoutUseSite: Boolean = false,
-): Boolean = hasAnnotation(StandardClassIds.Annotations.Deprecated, annotationUseSiteTarget, acceptAnnotationsWithoutUseSite)
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
+): Boolean = hasAnnotation(StandardClassIds.Annotations.Deprecated, useSiteTargetFilter)

 internal fun KtAnnotatedSymbol.hasJvmOverloadsAnnotation(): Boolean = hasAnnotation(JVM_OVERLOADS_CLASS_ID)

 internal fun KtAnnotatedSymbol.hasJvmStaticAnnotation(
-    annotationUseSiteTarget: AnnotationUseSiteTarget? = null,
-    acceptAnnotationsWithoutUseSite: Boolean = false,
-): Boolean = hasAnnotation(StandardClassIds.Annotations.JvmStatic, annotationUseSiteTarget, acceptAnnotationsWithoutUseSite)
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
+): Boolean = hasAnnotation(StandardClassIds.Annotations.JvmStatic, useSiteTargetFilter)

 internal fun KtAnnotatedSymbol.hasInlineOnlyAnnotation(): Boolean = hasAnnotation(StandardClassIds.Annotations.InlineOnly)

 internal fun KtAnnotatedSymbol.findAnnotation(
    classId: ClassId,
-    annotationUseSiteTarget: AnnotationUseSiteTarget?,
-    acceptAnnotationsWithoutUseSite: Boolean = false,
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
 ): KtAnnotationApplicationWithArgumentsInfo? {
-    if (!hasAnnotation(classId, annotationUseSiteTarget, acceptAnnotationsWithoutUseSite)) return null
+    if (!hasAnnotation(classId, useSiteTargetFilter)) return null

-    return annotations.find {
-        val useSiteTarget = it.useSiteTarget
-        (useSiteTarget == annotationUseSiteTarget || acceptAnnotationsWithoutUseSite && useSiteTarget == null) && it.classId == classId
-    }
+    return annotationsByClassId(classId, useSiteTargetFilter).firstOrNull()
 }

 context(KtAnalysisSession)
 internal fun KtAnnotatedSymbol.computeThrowsList(
    builder: LightReferenceListBuilder,
-    annotationUseSiteTarget: AnnotationUseSiteTarget?,
    useSitePosition: PsiElement,
    containingClass: SymbolLightClassBase,
-    acceptAnnotationsWithoutUseSite: Boolean = false,
+    useSiteTargetFilter: AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter,
 ) {
    if (containingClass.isEnum && this is KtFunctionSymbol && name == StandardNames.ENUM_VALUE_OF && isStatic) {
        builder.addReference(java.lang.IllegalArgumentException::class.qualifiedName)
        builder.addReference(java.lang.NullPointerException::class.qualifiedName)
    }

-    val annoApp = findAnnotation(StandardClassIds.Annotations.Throws, annotationUseSiteTarget, acceptAnnotationsWithoutUseSite) ?: return
+    val annoApp = findAnnotation(StandardClassIds.Annotations.Throws, useSiteTargetFilter) ?: return

    fun handleAnnotationValue(annotationValue: KtAnnotationValue) = when (annotationValue) {
        is KtArrayAnnotationValue -> {
@@ -71,8 +71,7 @@ class SymbolLightClassForFacade(
                    annotationsProvider = SymbolAnnotationsProvider(
                        ktModule = this.ktModule,
                        annotatedSymbolPointer = firstFileInFacade.symbolPointerOfType<KtFileSymbol>(),
-                        annotationUseSiteTarget = AnnotationUseSiteTarget.FILE,
-                        acceptAnnotationsWithoutSite = true,
+                        annotationUseSiteTargetFilter = AnnotationUseSiteTarget.FILE.toFilterWithAdditionalNull(),
                    )
                )
            },
@@ -34,10 +34,7 @@ import org.jetbrains.kotlin.config.JvmDefaultMode
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.lexer.KtTokens.*
-import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmFieldAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmOverloadsAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.annotations.hasJvmStaticAnnotation
-import org.jetbrains.kotlin.light.classes.symbol.annotations.isHiddenOrSynthetic
+import org.jetbrains.kotlin.light.classes.symbol.annotations.*
 import org.jetbrains.kotlin.light.classes.symbol.copy
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightField
 import org.jetbrains.kotlin.light.classes.symbol.fields.SymbolLightFieldForEnumEntry
@@ -311,15 +308,16 @@ internal fun SymbolLightClassBase.createPropertyAccessors(
    if (this !is SymbolLightClassForFacade && propertyTypeIsValueClass) return

    fun KtPropertyAccessorSymbol.needToCreateAccessor(siteTarget: AnnotationUseSiteTarget): Boolean {
+        val useSiteTargetFilterForPropertyAccessor = siteTarget.toFilterWithAdditionalNull()
        if (onlyJvmStatic &&
-            !hasJvmStaticAnnotation(siteTarget, acceptAnnotationsWithoutUseSite = true) &&
-            !declaration.hasJvmStaticAnnotation(siteTarget, acceptAnnotationsWithoutUseSite = true)
+            !hasJvmStaticAnnotation(useSiteTargetFilterForPropertyAccessor) &&
+            !declaration.hasJvmStaticAnnotation(useSiteTargetFilterForPropertyAccessor)
        ) return false

        if (declaration.hasReifiedParameters) return false
        if (!hasBody && visibility.isPrivateOrPrivateToThis()) return false
        if (declaration.isHiddenOrSynthetic(siteTarget)) return false
-        return !isHiddenOrSynthetic(siteTarget, acceptAnnotationsWithoutUseSite = true)
+        return !isHiddenOrSynthetic(siteTarget, useSiteTargetFilterForPropertyAccessor)
    }

    val originalElement = declaration.sourcePsiSafe<KtDeclaration>()
@@ -403,8 +401,9 @@ private fun hasBackingField(property: KtPropertySymbol): Boolean {
        return hasBackingFieldByPsi
    }

+    val fieldUseSite = AnnotationUseSiteTarget.FIELD
    if (property.modality == Modality.ABSTRACT ||
-        property.isHiddenOrSynthetic(AnnotationUseSiteTarget.FIELD, acceptAnnotationsWithoutUseSite = true)
+        property.isHiddenOrSynthetic(fieldUseSite, fieldUseSite.toFilterWithAdditionalNull())
    ) return false

    return hasBackingFieldByPsi ?: property.hasBackingField
@@ -7,14 +7,17 @@ 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.annotations.FieldAnnotationUseSiteTargetFilter
+import org.jetbrains.kotlin.analysis.api.annotations.NullAnnotationUseSiteTargetFilter
+import org.jetbrains.kotlin.analysis.api.annotations.PropertyAnnotationUseSiteTargetFilter
 import org.jetbrains.kotlin.analysis.api.symbols.KtEnumEntrySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.symbolPointerOfType
 import org.jetbrains.kotlin.asJava.classes.cannotModify
 import org.jetbrains.kotlin.asJava.classes.lazyPub
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.analyzeForLightClasses
 import org.jetbrains.kotlin.light.classes.symbol.annotations.LazyAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolAnnotationsProvider
+import org.jetbrains.kotlin.light.classes.symbol.annotations.annotationUseSiteTargetFilterOf
 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
@@ -42,8 +45,11 @@ internal class SymbolLightFieldForEnumEntry(
                annotationsProvider = SymbolAnnotationsProvider(
                    ktModule = ktModule,
                    annotatedSymbolPointer = enumEntry.symbolPointerOfType<KtEnumEntrySymbol>(),
-                    annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD,
-                    acceptAnnotationsWithoutSite = true,
+                    annotationUseSiteTargetFilter = annotationUseSiteTargetFilterOf(
+                        NullAnnotationUseSiteTargetFilter,
+                        FieldAnnotationUseSiteTargetFilter,
+                        PropertyAnnotationUseSiteTargetFilter,
+                    ),
                )
            ),
        )
@@ -19,10 +19,7 @@ import org.jetbrains.kotlin.asJava.builder.LightMemberOrigin
 import org.jetbrains.kotlin.asJava.classes.lazyPub
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.*
-import org.jetbrains.kotlin.light.classes.symbol.annotations.LazyAnnotationsBox
-import org.jetbrains.kotlin.light.classes.symbol.annotations.NullabilityAnnotationsProvider
-import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolAnnotationsProvider
-import org.jetbrains.kotlin.light.classes.symbol.annotations.hasDeprecatedAnnotation
+import org.jetbrains.kotlin.light.classes.symbol.annotations.*
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.LazyModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
@@ -90,7 +87,7 @@ internal class SymbolLightFieldForProperty private constructor(

    private val _isDeprecated: Boolean by lazyPub {
        withPropertySymbol { propertySymbol ->
-            propertySymbol.hasDeprecatedAnnotation(AnnotationUseSiteTarget.FIELD, acceptAnnotationsWithoutUseSite = true)
+            propertySymbol.hasDeprecatedAnnotation(AnnotationUseSiteTarget.FIELD.toFilterWithAdditionalNull())
        }
    }

@@ -126,12 +123,20 @@ internal class SymbolLightFieldForProperty private constructor(
        }

        PsiModifier.VOLATILE -> withPropertySymbol { propertySymbol ->
-            val hasAnnotation = propertySymbol.hasAnnotation(VOLATILE_ANNOTATION_CLASS_ID, null)
+            val hasAnnotation = propertySymbol.hasAnnotation(
+                VOLATILE_ANNOTATION_CLASS_ID,
+                AnnotationUseSiteTarget.FIELD.toFilterWithAdditionalNull(),
+            )
+
            mapOf(modifier to hasAnnotation)
        }

        PsiModifier.TRANSIENT -> withPropertySymbol { propertySymbol ->
-            val hasAnnotation = propertySymbol.hasAnnotation(TRANSIENT_ANNOTATION_CLASS_ID, null)
+            val hasAnnotation = propertySymbol.hasAnnotation(
+                TRANSIENT_ANNOTATION_CLASS_ID,
+                AnnotationUseSiteTarget.FIELD.toFilterWithAdditionalNull(),
+            )
+
            mapOf(modifier to hasAnnotation)
        }

@@ -152,8 +157,7 @@ internal class SymbolLightFieldForProperty private constructor(
                annotationsProvider = SymbolAnnotationsProvider(
                    ktModule = ktModule,
                    annotatedSymbolPointer = propertySymbolPointer,
-                    annotationUseSiteTarget = AnnotationUseSiteTarget.FIELD,
-                    acceptAnnotationsWithoutSite = true,
+                    annotationUseSiteTargetFilter = AnnotationUseSiteTarget.FIELD.toFilterWithAdditionalNull(),
                ),
                additionalAnnotationsProvider = NullabilityAnnotationsProvider {
                    withPropertySymbol { propertySymbol ->
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
 import org.jetbrains.kotlin.analysis.api.KtConstantValueForAnnotation
 import org.jetbrains.kotlin.analysis.api.KtNonConstantInitializerValue
+import org.jetbrains.kotlin.analysis.api.annotations.toFilter
 import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
@@ -90,7 +91,7 @@ internal class SymbolLightAccessorMethod private constructor(

    private val _name: String by lazyPub {
        analyzeForLightClasses(ktModule) {
-            propertyAccessorSymbol().getJvmNameFromAnnotation(accessorSite) ?: run {
+            propertyAccessorSymbol().getJvmNameFromAnnotation(accessorSite.toFilterWithAdditionalNull()) ?: run {
                val symbol = propertySymbol()
                val defaultName = symbol.name.identifier.let {
                    if (this@SymbolLightAccessorMethod.containingClass.isAnnotationType) it else it.abiName()
@@ -133,10 +134,9 @@ internal class SymbolLightAccessorMethod private constructor(
        propertyAccessorSymbolPointer.withSymbol(ktModule) { accessorSymbol ->
            accessorSymbol.computeThrowsList(
                builder,
-                accessorSite,
                this@SymbolLightAccessorMethod,
                containingClass,
-                acceptAnnotationsWithoutUseSite = true,
+                accessorSite.toFilterWithAdditionalNull(),
            )
        }
    }
@@ -171,9 +171,12 @@ internal class SymbolLightAccessorMethod private constructor(

    private fun isStatic(): Boolean = analyzeForLightClasses(ktModule) {
        val propertySymbol = propertySymbol()
-        propertySymbol.isStatic ||
-                propertySymbol.hasJvmStaticAnnotation(accessorSite, acceptAnnotationsWithoutUseSite = true) ||
-                propertyAccessorSymbol().hasJvmStaticAnnotation(accessorSite, acceptAnnotationsWithoutUseSite = true)
+        if (propertySymbol.isStatic) {
+            return@analyzeForLightClasses true
+        }
+
+        val filter = accessorSite.toFilterWithAdditionalNull()
+        propertySymbol.hasJvmStaticAnnotation(filter) || propertyAccessorSymbol().hasJvmStaticAnnotation(filter)
    }

    private val _modifierList: PsiModifierList by lazyPub {
@@ -185,13 +188,12 @@ internal class SymbolLightAccessorMethod private constructor(
                    SymbolAnnotationsProvider(
                        ktModule = ktModule,
                        annotatedSymbolPointer = propertyAccessorSymbolPointer,
-                        annotationUseSiteTarget = accessorSite,
-                        acceptAnnotationsWithoutSite = true,
+                        annotationUseSiteTargetFilter = accessorSite.toFilterWithAdditionalNull(),
                    ),
                    SymbolAnnotationsProvider(
                        ktModule = ktModule,
                        annotatedSymbolPointer = containingPropertySymbolPointer,
-                        annotationUseSiteTarget = accessorSite,
+                        annotationUseSiteTargetFilter = accessorSite.toFilter(),
                    ),
                ),
                additionalAnnotationsProvider = NullabilityAnnotationsProvider {
@@ -217,8 +219,8 @@ internal class SymbolLightAccessorMethod private constructor(

    private val _isDeprecated: Boolean by lazyPub {
        analyzeForLightClasses(ktModule) {
-            propertySymbol().hasDeprecatedAnnotation(accessorSite, acceptAnnotationsWithoutUseSite = true) ||
-                    propertyAccessorSymbol().hasDeprecatedAnnotation(accessorSite, acceptAnnotationsWithoutUseSite = true)
+            val filter = accessorSite.toFilterWithAdditionalNull()
+            propertySymbol().hasDeprecatedAnnotation(filter) || propertyAccessorSymbol().hasDeprecatedAnnotation(filter)
        }
    }

@@ -128,9 +128,8 @@ internal abstract class SymbolLightMethod<FType : KtFunctionLikeSymbol> private
        withFunctionSymbol { functionSymbol ->
            functionSymbol.computeThrowsList(
                builder,
-                annotationUseSiteTarget = null,
                this@SymbolLightMethod,
-                containingClass
+                containingClass,
            )
        }
    }
@@ -12,6 +12,7 @@ import com.intellij.psi.impl.light.LightReferenceListBuilder
 import com.intellij.psi.util.MethodSignature
 import com.intellij.psi.util.MethodSignatureBackedByPsiMethod
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.annotations.toFilter
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotatedSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
@@ -28,6 +29,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.SymbolLightMemberBase
 import org.jetbrains.kotlin.light.classes.symbol.annotations.getJvmNameFromAnnotation
 import org.jetbrains.kotlin.light.classes.symbol.annotations.hasPublishedApiAnnotation
+import org.jetbrains.kotlin.light.classes.symbol.annotations.toFilterWithAdditionalNull
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase

 internal abstract class SymbolLightMethodBase(
@@ -105,12 +107,13 @@ internal abstract class SymbolLightMethodBase(
    protected fun <T> T.computeJvmMethodName(
        defaultName: String,
        containingClass: SymbolLightClassBase,
-        annotationUseSiteTarget: AnnotationUseSiteTarget?,
+        annotationUseSiteTarget: AnnotationUseSiteTarget? = null,
    ): String where T : KtAnnotatedSymbol, T : KtSymbolWithVisibility, T : KtCallableSymbol {
-        getJvmNameFromAnnotation(annotationUseSiteTarget)?.let { return it }
+        getJvmNameFromAnnotation(annotationUseSiteTarget.toFilterWithAdditionalNull())?.let { return it }
+
        if (visibility != Visibilities.Internal) return defaultName
        if (containingClass is KtLightClassForFacade) return defaultName
-        if (hasPublishedApiAnnotation(annotationUseSiteTarget)) return defaultName
+        if (hasPublishedApiAnnotation(annotationUseSiteTarget.toFilter())) return defaultName

        val moduleName = (ktModule as? KtSourceModule)?.moduleName ?: return defaultName
        return mangleInternalName(defaultName, moduleName)
@@ -50,7 +50,6 @@ internal class SymbolLightSimpleMethod(
            functionSymbol.computeJvmMethodName(
                functionSymbol.name.asString(),
                this@SymbolLightSimpleMethod.containingClass,
-                annotationUseSiteTarget = null,
            )
        }
    }
@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.annotations.LazyAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.NullabilityAnnotationsProvider
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolAnnotationsProvider
+import org.jetbrains.kotlin.light.classes.symbol.annotations.toFilterWithAdditionalNull
 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
@@ -34,10 +35,9 @@ internal class SymbolLightParameter(
                annotationsProvider = SymbolAnnotationsProvider(
                    ktModule = ktModule,
                    annotatedSymbolPointer = parameterSymbolPointer,
-                    annotationUseSiteTarget = isConstructorParameterSymbol.ifTrue {
+                    annotationUseSiteTargetFilter = isConstructorParameterSymbol.ifTrue {
                        AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER
-                    },
-                    acceptAnnotationsWithoutSite = true,
+                    }.toFilterWithAdditionalNull(),
                ),
                additionalAnnotationsProvider = NullabilityAnnotationsProvider(::nullabilityType),
            ),
@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.light.classes.symbol.*
 import org.jetbrains.kotlin.light.classes.symbol.annotations.LazyAnnotationsBox
 import org.jetbrains.kotlin.light.classes.symbol.annotations.NullabilityAnnotationsProvider
 import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolAnnotationsProvider
+import org.jetbrains.kotlin.light.classes.symbol.annotations.toFilterWithAdditionalNull
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightClassModifierList
 import org.jetbrains.kotlin.psi.KtParameter
@@ -71,8 +72,7 @@ internal class SymbolLightParameterForReceiver private constructor(
                annotationsProvider = SymbolAnnotationsProvider(
                    ktModule = ktModule,
                    annotatedSymbolPointer = receiverPointer,
-                    annotationUseSiteTarget = AnnotationUseSiteTarget.RECEIVER,
-                    acceptAnnotationsWithoutSite = true,
+                    annotationUseSiteTargetFilter = AnnotationUseSiteTarget.RECEIVER.toFilterWithAdditionalNull(),
                ),
                additionalAnnotationsProvider = NullabilityAnnotationsProvider {
                    withReceiverSymbol { receiver ->
@@ -7,15 +7,13 @@ package org.jetbrains.kotlin.light.classes.symbol.parameters

 import com.intellij.psi.PsiModifierList
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
+import org.jetbrains.kotlin.analysis.api.annotations.SetterParameterAnnotationUseSiteTargetFilter
 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.annotations.CompositeAnnotationsProvider
-import org.jetbrains.kotlin.light.classes.symbol.annotations.LazyAnnotationsBox
-import org.jetbrains.kotlin.light.classes.symbol.annotations.NullabilityAnnotationsProvider
-import org.jetbrains.kotlin.light.classes.symbol.annotations.SymbolAnnotationsProvider
+import org.jetbrains.kotlin.light.classes.symbol.annotations.*
 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
@@ -48,13 +46,12 @@ internal class SymbolLightSetterParameter(
                    SymbolAnnotationsProvider(
                        ktModule = ktModule,
                        annotatedSymbolPointer = parameterSymbolPointer,
-                        annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
-                        acceptAnnotationsWithoutSite = true,
+                        annotationUseSiteTargetFilter = AnnotationUseSiteTarget.SETTER_PARAMETER.toFilterWithAdditionalNull(),
                    ),
                    SymbolAnnotationsProvider(
                        ktModule = ktModule,
                        annotatedSymbolPointer = containingPropertySymbolPointer,
-                        annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER,
+                        annotationUseSiteTargetFilter = SetterParameterAnnotationUseSiteTargetFilter,
                    ),
                ),
                additionalAnnotationsProvider = NullabilityAnnotationsProvider(::nullabilityType),
@@ -120,6 +120,12 @@ public class SymbolLightClassesByPsiForLibraryTestGenerated extends AbstractSymb
        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/exposedAnonymousType.kt");
    }

+    @Test
+    @TestMetadata("fieldModifiers.kt")
+    public void testFieldModifiers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/fieldModifiers.kt");
+    }
+
    @Test
    @TestMetadata("generics.kt")
    public void testGenerics() throws Exception {
@@ -120,6 +120,12 @@ public class SymbolLightClassesByPsiForSourceTestGenerated extends AbstractSymbo
        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/exposedAnonymousType.kt");
    }

+    @Test
+    @TestMetadata("fieldModifiers.kt")
+    public void testFieldModifiers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/fieldModifiers.kt");
+    }
+
    @Test
    @TestMetadata("generics.kt")
    public void testGenerics() throws Exception {