[SLC] implement java annotations for annotation classes

^KT-55481 Fixed
2022-12-14 16:37:40 +01:00
parent 1e1525bae5
commit f3c7972d20
16 changed files with 204 additions and 88 deletions
@@ -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)
        }
    }

@@ -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.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.*
 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()) {
-        if (parentIsAnnotation) {
-            result.add(createRetentionRuntimeAnnotation(modifierList))
-        }
-
-        if (nullabilityAnnotation != null) {
-            result.add(nullabilityAnnotation)
-        }
-
-        return result
-    }
-
+    val foundAnnotations = hashSetOf<String>()
    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 &&
-        annotations.none { it.classId?.asFqNameString() == JAVA_LANG_ANNOTATION_RETENTION }
-    ) {
-        val argumentWithKotlinRetention = annotations.firstOrNull { it.classId == StandardClassIds.Annotations.Retention }
-            ?.arguments
-            ?.firstOrNull { it.name.asString() == "value" }
-            ?.expression
-        val kotlinRetentionName = (argumentWithKotlinRetention as? KtEnumEntryAnnotationValue)?.callableId?.callableName?.asString()
-        result.add(createRetentionRuntimeAnnotation(modifierList, kotlinRetentionName))
+    if (parentIsAnnotation) {
+        for (annotation in annotations) {
+            val convertedAnnotation = annotation.tryConvertAsRetention(foundAnnotations, modifierList)
+                ?: annotation.tryConvertAsTarget(foundAnnotations, modifierList)
+                ?: annotation.tryConvertAsMustBeDocumented(foundAnnotations, modifierList)
+                ?: annotation.tryConvertAsRepeatable(foundAnnotations, modifierList, this)
+                ?: continue
+
+            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 =
-    SymbolLightSimpleAnnotation(
-        JAVA_LANG_ANNOTATION_RETENTION,
-        modifierList,
-        listOf(
+private fun KtAnnotationApplication.tryConvertAsRetention(foundAnnotations: Set<String>, modifierList: PsiModifierList): PsiAnnotation? {
+    if (classId != StandardClassIds.Annotations.Retention) return null
+    if (JvmAnnotationNames.RETENTION_ANNOTATION.asString() in foundAnnotations) return null
+
+    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(
-                    callableId = CallableId(
-                        ClassId.fromString(RETENTION_POLICY_ENUM.asString()),
-                        Name.identifier(retentionName ?: AnnotationRetention.RUNTIME.name),
-                    ),
+                expression = KtArrayAnnotationValue(
+                    values = javaTargetNames.map {
+                        KtEnumEntryAnnotationValue(
+                            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,
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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 {
@@ -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()
@@ -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>)
@@ -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()
-
-}
@@ -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()
-
-}
@@ -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()
-
-}}
@@ -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()
-
-}}
@@ -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})
@@ -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*/ {
 }
@@ -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");
@@ -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 {