[SLC] implement java annotations for annotation classes

^KT-55481 Fixed

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/configurators/AnalysisApiFirSourceTestConfigurator.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.services.TestModuleStructure
 import org.jetbrains.kotlin.test.services.TestServices
+import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator
 
 class AnalysisApiFirSourceTestConfigurator(override val analyseInDependentSession: Boolean) : AnalysisApiTestConfigurator() {
     override val frontendKind: FrontendKind get() = FrontendKind.Fir
@@ -32,6 +33,7 @@ class AnalysisApiFirSourceTestConfigurator(override val analyseInDependentSessio
             useDirectives(SealedClassesInheritorsCaclulatorPreAnalysisHandler.Directives)
             usePreAnalysisHandlers(::SealedClassesInheritorsCaclulatorPreAnalysisHandler)
             configureOptionalTestCompilerPlugin()
+            useConfigurators(::JvmEnvironmentConfigurator)
         }
     }
 

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

@@ -5,19 +5,16 @@
 
 package org.jetbrains.kotlin.light.classes.symbol.annotations
 
-import com.intellij.psi.CommonClassNames.JAVA_LANG_ANNOTATION_RETENTION
+import com.intellij.psi.*
-import com.intellij.psi.PsiAnnotation
-import com.intellij.psi.PsiClass
-import com.intellij.psi.PsiModifierList
-import com.intellij.psi.PsiClassType
-import com.intellij.psi.PsiElement
 import com.intellij.psi.impl.light.LightReferenceListBuilder
 import org.jetbrains.annotations.NotNull
 import org.jetbrains.annotations.Nullable
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.annotations.*
+import org.jetbrains.kotlin.analysis.api.annotations.KtKClassAnnotationValue.KtNonLocalKClassAnnotationValue
 import org.jetbrains.kotlin.analysis.api.components.buildClassType
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
+import org.jetbrains.kotlin.analysis.api.symbols.KtNamedClassOrObjectSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtAnnotatedSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
 import org.jetbrains.kotlin.builtins.StandardNames.DEFAULT_VALUE_PARAMETER
@@ -25,8 +22,9 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.light.classes.symbol.NullabilityType
 import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassBase
 import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethod
+import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_CLASS_ID
-import org.jetbrains.kotlin.load.java.JvmAnnotationNames.RETENTION_POLICY_ENUM
+import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.name.JvmNames.JVM_MULTIFILE_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.JVM_NAME_CLASS_ID
@@ -134,11 +132,12 @@ internal fun NullabilityType.computeNullabilityAnnotation(parent: PsiModifierLis
     }
 }
 
+context(KtAnalysisSession)
 internal fun KtAnnotatedSymbol.computeAnnotations(
     modifierList: PsiModifierList,
     nullability: NullabilityType,
     annotationUseSiteTarget: AnnotationUseSiteTarget?,
-    includeAnnotationsWithoutSite: Boolean = true
+    includeAnnotationsWithoutSite: Boolean = true,
 ): List<PsiAnnotation> {
     val parent = modifierList.parent
     val nullabilityAnnotation = nullability.computeNullabilityAnnotation(modifierList)
@@ -152,38 +151,30 @@ internal fun KtAnnotatedSymbol.computeAnnotations(
         }
     }
 
-    if (annotations.isEmpty()) {
+    val foundAnnotations = hashSetOf<String>()
-        if (parentIsAnnotation) {
-            result.add(createRetentionRuntimeAnnotation(modifierList))
-        }
-
-        if (nullabilityAnnotation != null) {
-            result.add(nullabilityAnnotation)
-        }
-
-        return result
-    }
-
     for (annotation in annotations) {
+        annotation.classId?.asFqNameString()?.let(foundAnnotations::add)
 
         val siteTarget = annotation.useSiteTarget
-
+        if (includeAnnotationsWithoutSite && siteTarget == null || siteTarget == annotationUseSiteTarget) {
-        if ((includeAnnotationsWithoutSite && siteTarget == null) ||
-            siteTarget == annotationUseSiteTarget
-        ) {
             result.add(SymbolLightAnnotationForAnnotationCall(annotation, modifierList))
         }
     }
 
-    if (parentIsAnnotation &&
+    if (parentIsAnnotation) {
-        annotations.none { it.classId?.asFqNameString() == JAVA_LANG_ANNOTATION_RETENTION }
+        for (annotation in annotations) {
-    ) {
+            val convertedAnnotation = annotation.tryConvertAsRetention(foundAnnotations, modifierList)
-        val argumentWithKotlinRetention = annotations.firstOrNull { it.classId == StandardClassIds.Annotations.Retention }
+                ?: annotation.tryConvertAsTarget(foundAnnotations, modifierList)
-            ?.arguments
+                ?: annotation.tryConvertAsMustBeDocumented(foundAnnotations, modifierList)
-            ?.firstOrNull { it.name.asString() == "value" }
+                ?: annotation.tryConvertAsRepeatable(foundAnnotations, modifierList, this)
-            ?.expression
+                ?: continue
-        val kotlinRetentionName = (argumentWithKotlinRetention as? KtEnumEntryAnnotationValue)?.callableId?.callableName?.asString()
+
-        result.add(createRetentionRuntimeAnnotation(modifierList, kotlinRetentionName))
+            result += convertedAnnotation
+        }
+
+        if (StandardClassIds.Annotations.Retention.asFqNameString() !in foundAnnotations) {
+            result += createRetentionAnnotation(modifierList)
+        }
     }
 
     if (nullabilityAnnotation != null) {
@@ -193,23 +184,137 @@ internal fun KtAnnotatedSymbol.computeAnnotations(
     return result
 }
 
-private fun createRetentionRuntimeAnnotation(modifierList: PsiModifierList, retentionName: String? = null): PsiAnnotation =
+private fun KtAnnotationApplication.tryConvertAsRetention(foundAnnotations: Set<String>, modifierList: PsiModifierList): PsiAnnotation? {
-    SymbolLightSimpleAnnotation(
+    if (classId != StandardClassIds.Annotations.Retention) return null
-        JAVA_LANG_ANNOTATION_RETENTION,
+    if (JvmAnnotationNames.RETENTION_ANNOTATION.asString() in foundAnnotations) return null
-        modifierList,
+
-        listOf(
+    val argumentWithKotlinRetention = arguments.firstOrNull { it.name.asString() == "value" }?.expression as? KtEnumEntryAnnotationValue
+    val kotlinRetentionName = argumentWithKotlinRetention?.callableId?.callableName?.asString()
+    return createRetentionAnnotation(modifierList, kotlinRetentionName)
+}
+
+private fun KtAnnotationApplication.tryConvertAsTarget(
+    foundAnnotations: Set<String>,
+    modifierList: PsiModifierList
+): PsiAnnotation? = tryConvertAs(
+    foundAnnotations = foundAnnotations,
+    modifierList = modifierList,
+    kotlinClassId = StandardClassIds.Annotations.Target,
+    javaQualifier = JvmAnnotationNames.TARGET_ANNOTATION.asString(),
+    argumentsComputer = fun(): List<KtNamedAnnotationValue>? {
+        val allowedKotlinTargets = arguments.firstOrNull()?.expression as? KtArrayAnnotationValue ?: return null
+        val javaTargetNames = allowedKotlinTargets.values.mapNotNullTo(linkedSetOf(), KtAnnotationValue::mapToJavaTarget)
+        return listOf(
             KtNamedAnnotationValue(
                 name = DEFAULT_VALUE_PARAMETER,
-                expression = KtEnumEntryAnnotationValue(
+                expression = KtArrayAnnotationValue(
-                    callableId = CallableId(
+                    values = javaTargetNames.map {
-                        ClassId.fromString(RETENTION_POLICY_ENUM.asString()),
+                        KtEnumEntryAnnotationValue(
-                        Name.identifier(retentionName ?: AnnotationRetention.RUNTIME.name),
+                            callableId = CallableId(
-                    ),
+                                classId = StandardClassIds.Annotations.Java.ElementType,
+                                callableName = Name.identifier(it),
+                            ),
+                            sourcePsi = null,
+                        )
+                    },
                     sourcePsi = null,
                 )
             )
         )
+    }
+)
+
+private fun KtAnnotationValue.mapToJavaTarget(): String? {
+    if (this !is KtEnumEntryAnnotationValue) return null
+    val callableId = callableId ?: return null
+    if (callableId.classId != StandardClassIds.AnnotationTarget) return null
+    return when (callableId.callableName.asString()) {
+        "CLASS" -> "TYPE"
+        "ANNOTATION_CLASS" -> "ANNOTATION_TYPE"
+        "FIELD" -> "FIELD"
+        "LOCAL_VARIABLE" -> "LOCAL_VARIABLE"
+        "VALUE_PARAMETER" -> "PARAMETER"
+        "CONSTRUCTOR" -> "CONSTRUCTOR"
+        "FUNCTION", "PROPERTY_GETTER", "PROPERTY_SETTER" -> "METHOD"
+        "TYPE_PARAMETER" -> "TYPE_PARAMETER"
+        "TYPE" -> "TYPE_USE"
+        else -> null
+    }
+}
+
+context(KtAnalysisSession)
+private fun KtAnnotationApplication.tryConvertAsRepeatable(
+    foundAnnotations: Set<String>,
+    modifierList: PsiModifierList,
+    ktAnnotatedSymbol: KtAnnotatedSymbol
+): PsiAnnotation? = tryConvertAs(
+    foundAnnotations = foundAnnotations,
+    modifierList = modifierList,
+    kotlinClassId = StandardClassIds.Annotations.Repeatable,
+    javaQualifier = JvmAnnotationNames.REPEATABLE_ANNOTATION.asString(),
+    argumentsComputer = fun(): List<KtNamedAnnotationValue>? {
+        if (ktAnnotatedSymbol !is KtNamedClassOrObjectSymbol) return null
+        val annotationClassId = ktAnnotatedSymbol.classIdIfNonLocal ?: return null
+
+        return listOf(
+            KtNamedAnnotationValue(
+                name = DEFAULT_VALUE_PARAMETER,
+                expression = KtNonLocalKClassAnnotationValue(
+                    classId = annotationClassId.createNestedClassId(Name.identifier(JvmAbi.REPEATABLE_ANNOTATION_CONTAINER_NAME)),
+                    sourcePsi = null,
+                )
+            )
+        )
+    },
+)
+
+private fun KtAnnotationApplication.tryConvertAsMustBeDocumented(
+    foundAnnotations: Set<String>,
+    modifierList: PsiModifierList,
+): PsiAnnotation? = tryConvertAs(
+    foundAnnotations = foundAnnotations,
+    modifierList = modifierList,
+    kotlinClassId = StandardClassIds.Annotations.MustBeDocumented,
+    javaQualifier = JvmAnnotationNames.DOCUMENTED_ANNOTATION.asString(),
+)
+
+private fun KtAnnotationApplication.tryConvertAs(
+    foundAnnotations: Set<String>,
+    modifierList: PsiModifierList,
+    kotlinClassId: ClassId,
+    javaQualifier: String,
+    argumentsComputer: (() -> List<KtNamedAnnotationValue>?)? = null,
+): PsiAnnotation? {
+    if (classId != kotlinClassId) return null
+    if (javaQualifier in foundAnnotations) return null
+    val arguments = if (argumentsComputer != null) {
+        argumentsComputer() ?: return null
+    } else {
+        emptyList()
+    }
+
+    return SymbolLightSimpleAnnotation(fqName = javaQualifier, parent = modifierList, arguments = arguments)
+}
+
+private fun createRetentionAnnotation(
+    modifierList: PsiModifierList,
+    retentionName: String? = null,
+): PsiAnnotation = SymbolLightSimpleAnnotation(
+    fqName = JvmAnnotationNames.RETENTION_ANNOTATION.asString(),
+    parent = modifierList,
+    arguments = listOf(
+        KtNamedAnnotationValue(
+            name = DEFAULT_VALUE_PARAMETER,
+            expression = KtEnumEntryAnnotationValue(
+                callableId = CallableId(
+                    StandardClassIds.Annotations.Java.RetentionPolicy,
+                    Name.identifier(retentionName ?: AnnotationRetention.RUNTIME.name),
+                ),
+                sourcePsi = null,
+            )
+        )
     )
+)
 
 context(KtAnalysisSession)
 internal fun KtAnnotatedSymbol.computeThrowsList(
@@ -225,7 +330,8 @@ internal fun KtAnnotatedSymbol.computeThrowsList(
         is KtArrayAnnotationValue -> {
             annotationValue.values.forEach(::handleAnnotationValue)
         }
-        is KtKClassAnnotationValue.KtNonLocalKClassAnnotationValue -> {
+
+        is KtNonLocalKClassAnnotationValue -> {
             val psiType = buildClassType(annotationValue.classId).asPsiType(
                 useSitePosition,
                 KtTypeMappingMode.DEFAULT,

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesForLibraryTestGenerated.java

@@ -48,6 +48,12 @@ public class SymbolLightClassesForLibraryTestGenerated extends AbstractSymbolLig
         runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
     }
 
+    @Test
+    @TestMetadata("AnnotationJavaRepeatable.kt")
+    public void testAnnotationJavaRepeatable() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.kt");
+    }
+
     @Test
     @TestMetadata("AnnotationJvmRepeatable.kt")
     public void testAnnotationJvmRepeatable() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingForLibraryTestGenerated.java

@@ -48,6 +48,12 @@ public class SymbolLightClassesParentingForLibraryTestGenerated extends Abstract
         runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
     }
 
+    @Test
+    @TestMetadata("AnnotationJavaRepeatable.kt")
+    public void testAnnotationJavaRepeatable() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.kt");
+    }
+
     @Test
     @TestMetadata("AnnotationJvmRepeatable.kt")
     public void testAnnotationJvmRepeatable() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesForSourceTestGenerated.java

@@ -48,6 +48,12 @@ public class SymbolLightClassesForSourceTestGenerated extends AbstractSymbolLigh
         runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
     }
 
+    @Test
+    @TestMetadata("AnnotationJavaRepeatable.kt")
+    public void testAnnotationJavaRepeatable() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.kt");
+    }
+
     @Test
     @TestMetadata("AnnotationJvmRepeatable.kt")
     public void testAnnotationJvmRepeatable() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingForSourceTestGenerated.java

@@ -48,6 +48,12 @@ public class SymbolLightClassesParentingForSourceTestGenerated extends AbstractS
         runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
     }
 
+    @Test
+    @TestMetadata("AnnotationJavaRepeatable.kt")
+    public void testAnnotationJavaRepeatable() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.kt");
+    }
+
     @Test
     @TestMetadata("AnnotationJvmRepeatable.kt")
     public void testAnnotationJvmRepeatable() throws Exception {

compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.java

@@ -1,4 +1,4 @@
-@java.lang.annotation.Repeatable()
+@java.lang.annotation.Repeatable(value = TwoContainer.class)
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
 public abstract @interface Two /* Two*/ {
   public abstract java.lang.String name();//  name()

compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.kt

@@ -0,0 +1,6 @@
+// Two
+// FULL_JDK
+
+@java.lang.annotation.Repeatable(TwoContainer::class)
+annotation class Two(val name: String)
+annotation class TwoContainer(val value: Array<Two>)

compiler/testData/asJava/lightClasses/AnnotationKotlinAndJavaRepeatable.fir.java

@@ -1,7 +0,0 @@
-@java.lang.annotation.Repeatable()
-@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
-@kotlin.annotation.Repeatable()
-public abstract @interface Two /* Two*/ {
-  public abstract java.lang.String name();//  name()
-
-}

compiler/testData/asJava/lightClasses/AnnotationKotlinAndJvmRepeatable.fir.java

@@ -1,7 +0,0 @@
-@java.lang.annotation.Repeatable()
-@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
-@kotlin.annotation.Repeatable()
-public abstract @interface Two /* Two*/ {
-  public abstract java.lang.String name();//  name()
-
-}

compiler/testData/asJava/lightClasses/AnnotationRepeatable.fir.java

@@ -1,12 +0,0 @@
-@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
-@kotlin.annotation.Repeatable()
-public abstract @interface One /* simple.One*/ {
-  public abstract java.lang.String value();//  value()
-
-
-@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
-@kotlin.jvm.internal.RepeatableContainer()
-public static abstract @interface Container /* simple.One.Container*/ {
-  public abstract simple.One[] value();//  value()
-
-}}

compiler/testData/asJava/lightClasses/SpecialAnnotationsOnAnnotationClass.fir.java

@@ -1,17 +0,0 @@
-@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.SOURCE)
-@kotlin.annotation.MustBeDocumented()
-@kotlin.annotation.Repeatable()
-@kotlin.annotation.Retention(value = kotlin.annotation.AnnotationRetention.SOURCE)
-@kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.TYPE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
-public abstract @interface Anno /* Anno*/ {
-  public abstract int i();//  i()
-
-
-@java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.SOURCE)
-@kotlin.annotation.Retention(value = kotlin.annotation.AnnotationRetention.SOURCE)
-@kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.TYPE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
-@kotlin.jvm.internal.RepeatableContainer()
-public static abstract @interface Container /* Anno.Container*/ {
-  public abstract Anno[] value();//  value()
-
-}}

compiler/testData/asJava/ultraLightClasses/annotations.fir.java

@@ -1,24 +1,29 @@
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.EXPRESSION})
 public abstract @interface Anno2 /* Anno2*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.EXPRESSION})
 public abstract @interface Anno3 /* Anno3*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.EXPRESSION})
 public abstract @interface Anno4 /* Anno4*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.EXPRESSION})
 public abstract @interface Anno5 /* Anno5*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.EXPRESSION})
 public abstract @interface Anno6 /* Anno6*/ {
 }
@@ -52,7 +57,9 @@ public abstract @interface Anno /* Anno*/ {
 }
 
 @Deprecated(message = "This anno is deprecated, use === instead", replaceWith = @ReplaceWith(expression = "this === other"))
+@java.lang.annotation.Documented()
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.SOURCE)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.TYPE, java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.PARAMETER})
 @kotlin.annotation.MustBeDocumented()
 @kotlin.annotation.Retention(value = kotlin.annotation.AnnotationRetention.SOURCE)
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.EXPRESSION})

compiler/testData/asJava/ultraLightClasses/typeAnnotations.fir.java

@@ -1,34 +1,41 @@
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A0 /* A0*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A1 /* A1*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A2 /* A2*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A3 /* A3*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A4 /* A4*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A5 /* A5*/ {
 }
 
 @java.lang.annotation.Retention(value = java.lang.annotation.RetentionPolicy.RUNTIME)
+@java.lang.annotation.Target(value = {java.lang.annotation.ElementType.PARAMETER, java.lang.annotation.ElementType.TYPE_USE})
 @kotlin.annotation.Target(allowedTargets = {kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.TYPE})
 public abstract @interface A6 /* A6*/ {
 }

compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java

@@ -49,6 +49,11 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
         runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt");
     }
 
+    @TestMetadata("AnnotationJavaRepeatable.kt")
+    public void testAnnotationJavaRepeatable() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/AnnotationJavaRepeatable.kt");
+    }
+
     @TestMetadata("AnnotationJvmRepeatable.kt")
     public void testAnnotationJvmRepeatable() throws Exception {
         runTest("compiler/testData/asJava/lightClasses/AnnotationJvmRepeatable.kt");

core/compiler.common/src/org/jetbrains/kotlin/name/StandardClassIds.kt

@@ -177,6 +177,8 @@ object StandardClassIds {
             val Retention = "Retention".javaAnnotationId()
             val Documented = "Documented".javaAnnotationId()
             val Target = "Target".javaAnnotationId()
+            val ElementType = "ElementType".javaAnnotationId()
+            val RetentionPolicy = "RetentionPolicy".javaAnnotationId()
         }
 
         object ParameterNames {