[FIR] Add ability to specify if meta annotation itself should match metaAnnotated predicate

^KT-55843 Fixed

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt

@@ -134,7 +134,7 @@ internal class LLFirIdePredicateBasedProvider(
 
         override fun visitMetaAnnotatedWith(predicate: AbstractPredicate.MetaAnnotatedWith<P>, data: FirDeclaration): Boolean {
             return data.annotations.any { annotation ->
-                annotation.markedWithMetaAnnotation(session, data, predicate.metaAnnotations)
+                annotation.markedWithMetaAnnotation(session, data, predicate.metaAnnotations, predicate.includeItself)
             }
         }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProviderImpl.kt

@@ -140,7 +140,7 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
 
         override fun visitMetaAnnotatedWith(predicate: AbstractPredicate.MetaAnnotatedWith<P>, data: FirDeclaration): Boolean {
             return data.annotations.any { annotation ->
-                annotation.markedWithMetaAnnotation(session, data, predicate.metaAnnotations)
+                annotation.markedWithMetaAnnotation(session, data, predicate.metaAnnotations, predicate.includeItself)
             }
         }
 
@@ -190,23 +190,25 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
 fun FirAnnotation.markedWithMetaAnnotation(
     session: FirSession,
     containingDeclaration: FirDeclaration,
-    metaAnnotations: Set<AnnotationFqn>
+    metaAnnotations: Set<AnnotationFqn>,
+    includeItself: Boolean
 ): Boolean {
     containingDeclaration.symbol.lazyResolveToPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
     return annotationTypeRef.coneTypeSafe<ConeKotlinType>()
         ?.toRegularClassSymbol(session)
-        .markedWithMetaAnnotationImpl(session, metaAnnotations, mutableSetOf())
+        .markedWithMetaAnnotationImpl(session, metaAnnotations, includeItself, mutableSetOf())
 }
 
 fun FirRegularClassSymbol?.markedWithMetaAnnotationImpl(
     session: FirSession,
     metaAnnotations: Set<AnnotationFqn>,
+    includeItself: Boolean,
     visited: MutableSet<FirRegularClassSymbol>
 ): Boolean {
     if (this == null) return false
     if (!visited.add(this)) return false
-    if (this.classId.asSingleFqName() in metaAnnotations) return true
+    if (this.classId.asSingleFqName() in metaAnnotations) return includeItself
     return this.resolvedCompilerAnnotationsWithClassIds
         .mapNotNull { it.annotationTypeRef.coneTypeSafe<ConeKotlinType>()?.toRegularClassSymbol(session) }
-        .any { it.markedWithMetaAnnotationImpl(session, metaAnnotations, visited) }
+        .any { it.markedWithMetaAnnotationImpl(session, metaAnnotations, includeItself = true, visited) }
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt

@@ -144,7 +144,7 @@ internal abstract class AbstractFirSpecificAnnotationResolveTransformer(
     }
 
     private fun ConeKotlinType.markedWithMetaAnnotation(session: FirSession, metaAnnotations: Set<AnnotationFqn>): Boolean {
-        return toRegularClassSymbol(session).markedWithMetaAnnotationImpl(session, metaAnnotations, mutableSetOf())
+        return toRegularClassSymbol(session).markedWithMetaAnnotationImpl(session, metaAnnotations, includeItself = true, mutableSetOf())
     }
 
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/AbstractPredicate.kt

@@ -169,8 +169,13 @@ sealed interface AbstractPredicate<P : AbstractPredicate<P>> {
 
     /**
      * Matches declarations, which are annotated with annotations which are annotated with [metaAnnotations]
+     *
+     * [includeItself] flag determines if declaration, annotated with meta-annotation itself will
+     *   be considered as matching to predicate
+     *
      * Relation "annotation with meta annotation" is transitive. E.g. in snippet below some declaration will
-     *   be matched with predicate MetaAnnotatedWith("Ann") if it is annotated with `@Ann`, `@Some` or `@Other`
+     *   be matched with predicate MetaAnnotatedWith("Ann") if it is annotated with `@Ann` (if [includeItself] set to true),
+     *   `@Some` or `@Other`
      *
      * @Ann
      * annotation class Some
@@ -200,6 +205,8 @@ sealed interface AbstractPredicate<P : AbstractPredicate<P>> {
      *   and can not be used for global lookup
      */
     sealed interface MetaAnnotatedWith<P : AbstractPredicate<P>> : AbstractPredicate<P> {
+        val includeItself: Boolean
+
         override fun <R, D> accept(visitor: PredicateVisitor<P, R, D>, data: D): R {
             return visitor.visitMetaAnnotatedWith(this, data)
         }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicate.kt

@@ -91,7 +91,8 @@ sealed class DeclarationPredicate : AbstractPredicate<DeclarationPredicate> {
     // ------------------------------------ MetaAnnotated ------------------------------------
 
     class MetaAnnotatedWith(
-        override val metaAnnotations: Set<AnnotationFqn>
+        override val metaAnnotations: Set<AnnotationFqn>,
+        override val includeItself: Boolean
     ) : DeclarationPredicate(), AbstractPredicate.MetaAnnotatedWith<DeclarationPredicate> {
         init {
             require(metaAnnotations.isNotEmpty()) {
@@ -122,7 +123,8 @@ sealed class DeclarationPredicate : AbstractPredicate<DeclarationPredicate> {
         override fun annotatedOrUnder(vararg annotations: AnnotationFqn): DeclarationPredicate =
             annotated(*annotations) or ancestorAnnotated(*annotations)
 
-        fun metaAnnotated(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = MetaAnnotatedWith(metaAnnotations.toSet())
+        fun metaAnnotated(vararg metaAnnotations: AnnotationFqn, includeItself: Boolean): DeclarationPredicate =
+            MetaAnnotatedWith(metaAnnotations.toSet(), includeItself)
 
         // ------------------- collections -------------------
         override fun annotated(annotations: Collection<AnnotationFqn>): DeclarationPredicate = AnnotatedWith(annotations.toSet())
@@ -137,7 +139,8 @@ sealed class DeclarationPredicate : AbstractPredicate<DeclarationPredicate> {
         override fun annotatedOrUnder(annotations: Collection<AnnotationFqn>): DeclarationPredicate =
             annotated(annotations) or ancestorAnnotated(annotations)
 
-        fun metaAnnotated(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = MetaAnnotatedWith(metaAnnotations.toSet())
+        fun metaAnnotated(metaAnnotations: Collection<AnnotationFqn>, includeItself: Boolean): DeclarationPredicate =
+            MetaAnnotatedWith(metaAnnotations.toSet(), includeItself)
     }
 
     companion object {

plugins/allopen/allopen.k2/src/org/jetbrains/kotlin/allopen/fir/FirAllOpenStatusTransformer.kt

@@ -57,7 +57,7 @@ class FirAllOpenPredicateMatcher(
 
     override val predicate = DeclarationPredicate.create {
         val annotationFqNames = allOpenAnnotationFqNames.map { FqName(it) }
-        annotated(annotationFqNames) or metaAnnotated(annotationFqNames)
+        annotated(annotationFqNames) or metaAnnotated(annotationFqNames, includeItself = true)
     }
 }
 

plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt

@@ -20,7 +20,7 @@ class AllOpenStatusTransformer(session: FirSession) : FirStatusTransformerExtens
     companion object {
         private val ALL_OPEN = FqName("org.jetbrains.kotlin.fir.plugin.AllOpen")
         private val PREDICATE = DeclarationPredicate.create {
-            annotatedOrUnder(ALL_OPEN) or metaAnnotated(ALL_OPEN)
+            annotatedOrUnder(ALL_OPEN) or metaAnnotated(ALL_OPEN, includeItself = true)
         }
     }
 

plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SomeAdditionalSupertypeGenerator.kt

@@ -31,7 +31,7 @@ class SomeAdditionalSupertypeGenerator(session: FirSession) : FirSupertypeGenera
     companion object {
         private val myInterfaceClassId = ClassId(FqName("foo"), Name.identifier("MyInterface"))
         private val PREDICATE = DeclarationPredicate.create {
-            annotated("MyInterfaceSupertype".fqn()) or metaAnnotated("MetaSupertype".fqn())
+            annotated("MyInterfaceSupertype".fqn()) or metaAnnotated("MetaSupertype".fqn(), includeItself = false)
         }
     }
 

plugins/fir-plugin-prototype/testData/diagnostics/supertypes/metaAnnotationOrder.fir.txt

@@ -24,14 +24,14 @@ FILE: main.kt
         }
 
     }
-    @R|org/jetbrains/kotlin/fir/plugin/MetaSupertype|() public final class Zero : R|kotlin/Any|, R|foo/MyInterface| {
+    @R|org/jetbrains/kotlin/fir/plugin/MetaSupertype|() public final class Zero : R|kotlin/Any| {
         public constructor(): R|foo/Zero| {
             super<R|kotlin/Any|>()
         }
 
     }
     public final fun test(a: R|foo/Zero|, b: R|foo/First|, c: R|foo/Second|, d: R|foo/Third|): R|kotlin/Unit| {
-        R|<local>/a|.R|foo/MyInterface.foo|()
+        R|<local>/a|.<Unresolved name: foo>#()
         R|<local>/b|.R|foo/MyInterface.foo|()
         R|<local>/c|.R|foo/MyInterface.foo|()
         R|<local>/d|.R|foo/MyInterface.foo|()

plugins/fir-plugin-prototype/testData/diagnostics/supertypes/metaAnnotationOrder.kt

@@ -21,7 +21,7 @@ class First
 class Zero
 
 fun test(a: Zero, b: First, c: Second, d: Third) {
-    a.foo()
+    a.<!UNRESOLVED_REFERENCE!>foo<!>() // should be an error, because meta predicate has inludeItself = false
     b.foo()
     c.foo()
     d.foo()

plugins/kotlinx-serialization/kotlinx-serialization.k2/src/org/jetbrains/kotlinx/serialization/compiler/fir/FirSerializationPredicates.kt

@@ -13,9 +13,10 @@ object FirSerializationPredicates {
         annotated(setOf(SerializationAnnotations.serializerAnnotationFqName)) // @Serializer(for=...)
     }
     internal val hasMetaAnnotation = DeclarationPredicate.create {
-        metaAnnotated(SerializationAnnotations.metaSerializableAnnotationFqName)
+        metaAnnotated(SerializationAnnotations.metaSerializableAnnotationFqName, includeItself = false)
     }
     internal val annotatedWithSerializableOrMeta = DeclarationPredicate.create {
-        annotated(setOf(SerializationAnnotations.serializableAnnotationFqName)) or metaAnnotated(SerializationAnnotations.metaSerializableAnnotationFqName)
+        annotated(setOf(SerializationAnnotations.serializableAnnotationFqName)) or
+                metaAnnotated(SerializationAnnotations.metaSerializableAnnotationFqName, includeItself = false)
     }
 }

plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt

@@ -22,7 +22,7 @@ class FirNoArgPredicateMatcher(
 
     override val predicate = DeclarationPredicate.create {
         val annotationFqNames = noArgAnnotationFqNames.map { FqName(it) }
-        annotated(annotationFqNames) or metaAnnotated(annotationFqNames)
+        annotated(annotationFqNames) or metaAnnotated(annotationFqNames, includeItself = true)
     }
 }