[FIR] Add to new types of annotation predicates

- `ParentAnnotatedWith` matches declarations, which parent is annotated
- `HasAnnotatedWith` matches declarations, which have at least one
     direct child with annotation

Also, `DeclarationPredicate.Any` is removed, because there is no
  intention to support lookup for all declarations in module

^KT-52486 Fixed

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

@@ -107,10 +107,6 @@ internal class LLFirIdePredicateBasedProvider(
                           "this method should never be called, but it was called with $predicate")
         }
 
-        override fun visitAny(predicate: DeclarationPredicate.Any, data: FirDeclaration): Boolean {
-            return true
-        }
-
         override fun visitAnd(predicate: DeclarationPredicate.And, data: FirDeclaration): Boolean {
             return predicate.a.accept(this, data) && predicate.b.accept(this, data)
         }

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

@@ -39,11 +39,20 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
         registerOwnersDeclarations(declaration, owners)
 
         if (declaration.annotations.isEmpty()) return
-        val matchingAnnotations = declaration.annotations.mapNotNull { it.fqName(session) }
+        val matchingAnnotations = declaration.annotations
+            .mapNotNull { it.fqName(session) }
             .filter { it in registeredPluginAnnotations.annotations }
-        if (matchingAnnotations.isEmpty()) return
+            .takeIf { it.isNotEmpty() }
+            ?: return
+
+        owners.lastOrNull()?.let { owner ->
+            matchingAnnotations.forEach { cache.declarationsHasAnnotated.put(it, owner) }
+            cache.annotationsOfHasAnnotated.putAll(owner, matchingAnnotations)
+        }
+
         matchingAnnotations.forEach { cache.declarationByAnnotation.put(it, declaration) }
         cache.annotationsOfDeclaration.putAll(declaration, matchingAnnotations)
+
         val file = owners.first() as FirFile
         cache.filesWithPluginAnnotations += file
     }
@@ -55,11 +64,14 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
     private fun registerOwnersDeclarations(declaration: FirDeclaration, owners: PersistentList<FirDeclaration>) {
         val lastOwner = owners.lastOrNull() ?: return
         val annotationsFromLastOwner = cache.annotationsOfDeclaration[lastOwner]
-        val annotationsFromPreviousOwners = cache.parentAnnotationsOfDeclaration[lastOwner]
+        val annotationsFromPreviousOwners = cache.annotationsOfUnderAnnotated[lastOwner]
+
+        annotationsFromLastOwner.forEach { cache.declarationsParentAnnotated.put(it, declaration) }
+        cache.annotationsOfParentAnnotated.putAll(declaration, annotationsFromLastOwner)
 
         val allParentDeclarations = annotationsFromLastOwner + annotationsFromPreviousOwners
         allParentDeclarations.forEach { cache.declarationsUnderAnnotated.put(it, declaration) }
-        cache.parentAnnotationsOfDeclaration.putAll(declaration, allParentDeclarations)
+        cache.annotationsOfUnderAnnotated.putAll(declaration, allParentDeclarations)
     }
 
     // ---------------------------------- Matching ----------------------------------
@@ -75,10 +87,6 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
             throw IllegalStateException("Should not be there")
         }
 
-        override fun visitAny(predicate: DeclarationPredicate.Any, data: FirDeclaration): Boolean {
-            return true
-        }
-
         override fun visitAnd(predicate: DeclarationPredicate.And, data: FirDeclaration): Boolean {
             return predicate.a.accept(this, data) && predicate.b.accept(this, data)
         }
@@ -87,6 +95,8 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
             return predicate.a.accept(this, data) || predicate.b.accept(this, data)
         }
 
+        // ------------------------------------ Annotated ------------------------------------
+
         override fun visitAnnotatedWith(predicate: AnnotatedWith, data: FirDeclaration): Boolean {
             return matchWith(data, predicate.annotations)
         }
@@ -95,6 +105,16 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
             return matchUnder(data, predicate.annotations)
         }
 
+        override fun visitParentAnnotatedWith(predicate: ParentAnnotatedWith, data: FirDeclaration): Boolean {
+            return matchParentWith(data, predicate.annotations)
+        }
+
+        override fun visitHasAnnotatedWith(predicate: HasAnnotatedWith, data: FirDeclaration): Boolean {
+            return matchHasAnnotatedWith(data, predicate.annotations)
+        }
+
+        // ------------------------------------ Meta Annotated ------------------------------------
+
         override fun visitAnnotatedWithMeta(predicate: AnnotatedWithMeta, data: FirDeclaration): Boolean {
             return matchWith(data, predicate.userDefinedAnnotations)
         }
@@ -103,6 +123,16 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
             return matchUnder(data, predicate.userDefinedAnnotations)
         }
 
+        override fun visitParentMetaAnnotatedWith(predicate: ParentMetaAnnotatedWith, data: FirDeclaration): Boolean {
+            return matchParentWith(data, predicate.userDefinedAnnotations)
+        }
+
+        override fun visitHasMetaAnnotatedWith(predicate: HasMetaAnnotatedWith, data: FirDeclaration): Boolean {
+            return matchHasAnnotatedWith(data, predicate.userDefinedAnnotations)
+        }
+
+        // ------------------------------------ Utilities ------------------------------------
+
         private val MetaAnnotated.userDefinedAnnotations: Set<AnnotationFqn>
             get() = metaAnnotations.flatMapTo(mutableSetOf()) { registeredPluginAnnotations.getAnnotationsWithMetaAnnotation(it) }
 
@@ -111,7 +141,15 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
         }
 
         private fun matchUnder(declaration: FirDeclaration, annotations: Set<AnnotationFqn>): Boolean {
-            return cache.parentAnnotationsOfDeclaration[declaration].any { it in annotations }
+            return cache.annotationsOfUnderAnnotated[declaration].any { it in annotations }
+        }
+
+        private fun matchParentWith(declaration: FirDeclaration, annotations: Set<AnnotationFqn>): Boolean {
+            return cache.annotationsOfParentAnnotated[declaration].any { it in annotations }
+        }
+
+        private fun matchHasAnnotatedWith(declaration: FirDeclaration, annotations: Set<AnnotationFqn>): Boolean {
+            return cache.annotationsOfHasAnnotated[declaration].any { it in annotations }
         }
     }
 
@@ -122,7 +160,13 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic
         val annotationsOfDeclaration: LinkedHashMultimap<FirDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
 
         val declarationsUnderAnnotated: Multimap<AnnotationFqn, FirDeclaration> = LinkedHashMultimap.create()
-        val parentAnnotationsOfDeclaration: LinkedHashMultimap<FirDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
+        val annotationsOfUnderAnnotated: LinkedHashMultimap<FirDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
+
+        val declarationsParentAnnotated: Multimap<AnnotationFqn, FirDeclaration> = LinkedHashMultimap.create()
+        val annotationsOfParentAnnotated: Multimap<FirDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
+
+        val declarationsHasAnnotated: Multimap<AnnotationFqn, FirDeclaration> = LinkedHashMultimap.create()
+        val annotationsOfHasAnnotated: Multimap<FirDeclaration, AnnotationFqn> = LinkedHashMultimap.create()
 
         val ownersForDeclaration: MutableMap<FirDeclaration, PersistentList<FirDeclaration>> = mutableMapOf()
 

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

@@ -15,17 +15,6 @@ sealed class DeclarationPredicate {
 
     abstract fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R
 
-    object Any : DeclarationPredicate() {
-        override val annotations: Set<AnnotationFqn>
-            get() = emptySet()
-        override val metaAnnotations: Set<AnnotationFqn>
-            get() = emptySet()
-
-        override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
-            return visitor.visitAny(this, data)
-        }
-    }
-
     class Or(val a: DeclarationPredicate, val b: DeclarationPredicate) : DeclarationPredicate() {
         override val annotations: Set<AnnotationFqn> = a.annotations + b.annotations
         override val metaAnnotations: Set<AnnotationFqn> = a.metaAnnotations + b.metaAnnotations
@@ -45,6 +34,12 @@ sealed class DeclarationPredicate {
     }
 }
 
+// ------------------------------------ Annotated ------------------------------------
+
+/**
+ * Base class for all predicates with specific annotations
+ *  Declaration will be matched if at least one of [annotations] is found
+ */
 sealed class Annotated(final override val annotations: Set<AnnotationFqn>) : DeclarationPredicate() {
     init {
         require(annotations.isNotEmpty()) {
@@ -60,28 +55,109 @@ sealed class Annotated(final override val annotations: Set<AnnotationFqn>) : Dec
     }
 }
 
+/**
+ * Matches declarations, which are annotated with [annotations]
+ *
+ * @Ann
+ * fun foo() {}
+ *
+ * fun bar(@Ann param: Int) {}
+ *
+ * @Ann
+ * class A {
+ *      fun baz() {}
+ *
+ *      class Nested {
+ *          fun foobar() {}
+ *      }
+ * }
+ *
+ * Matched symbols: [fun foo, parameter `param` from fun bar, class A]
+ */
 class AnnotatedWith(annotations: Set<AnnotationFqn>) : Annotated(annotations) {
     override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
         return visitor.visitAnnotatedWith(this, data)
     }
 }
 
+
+/**
+ * Matches declaration, if one of its containers annotated with [annotations]
+ *
+ * @Ann
+ * fun foo() {}
+ *
+ * fun bar(@Ann param: Int) {}
+ *
+ * @Ann
+ * class A {
+ *      fun baz() {}
+ *
+ *      class Nested {
+ *          fun foobar() {}
+ *      }
+ * }
+ *
+ * Matched symbols: [fun A.baz, class Nested, fun Nested.foobar]
+ */
 class UnderAnnotatedWith(annotations: Set<AnnotationFqn>) : Annotated(annotations) {
     override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
         return visitor.visitUnderAnnotatedWith(this, data)
     }
 }
 
-// annotation class AllOpen  // from library
-
-/*
-
-@AllOpen
-annotation class MyOpen
-
-@MyOpen
-class MyClass
+/**
+ * Matches declaration, if its direct container annotated with [annotations]
+ *
+ * @Ann
+ * fun foo() {}
+ *
+ * fun bar(@Ann param: Int) {}
+ *
+ * @Ann
+ * class A {
+ *      fun baz() {}
+ *
+ *      class Nested {
+ *          fun foobar() {}
+ *      }
+ * }
+ *
+ * Matched symbols: [fun A.baz, class Nested]
  */
+class ParentAnnotatedWith(annotations: Set<AnnotationFqn>) : Annotated(annotations) {
+    override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
+        return visitor.visitParentAnnotatedWith(this, data)
+    }
+}
+
+/**
+ * Matches declaration, if one of its direct child declarations annotated with [annotations]
+ *
+ * @Ann
+ * fun foo() {}
+ *
+ * fun bar(@Ann param: Int) {}
+ *
+ * class A {
+ *      @Ann
+ *      fun baz() {}
+ *
+ *      class Nested {
+ *          fun foobar() {}
+ *      }
+ * }
+ *
+ * Matched symbols: [fun bar, class A]
+ */
+
+class HasAnnotatedWith(annotations: Set<AnnotationFqn>) : Annotated(annotations) {
+    override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
+        return visitor.visitHasAnnotatedWith(this, data)
+    }
+}
+
+// ------------------------------------ MetaAnnotated ------------------------------------
 
 sealed class MetaAnnotated(final override val metaAnnotations: Set<AnnotationFqn>) : DeclarationPredicate() {
     init {
@@ -110,6 +186,18 @@ class UnderMetaAnnotated(metaAnnotations: Set<AnnotationFqn>) : MetaAnnotated(me
     }
 }
 
+class ParentMetaAnnotatedWith(metaAnnotations: Set<AnnotationFqn>) : MetaAnnotated(metaAnnotations) {
+    override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
+        return visitor.visitParentMetaAnnotatedWith(this, data)
+    }
+}
+
+class HasMetaAnnotatedWith(metaAnnotations: Set<AnnotationFqn>) : MetaAnnotated(metaAnnotations) {
+    override fun <R, D> accept(visitor: DeclarationPredicateVisitor<R, D>, data: D): R {
+        return visitor.visitHasMetaAnnotatedWith(this, data)
+    }
+}
+
 // -------------------------------------------- DSL --------------------------------------------
 
 infix fun DeclarationPredicate.or(other: DeclarationPredicate): DeclarationPredicate = DeclarationPredicate.Or(this, other)
@@ -117,18 +205,30 @@ infix fun DeclarationPredicate.and(other: DeclarationPredicate): DeclarationPred
 
 // ------------------- varargs -------------------
 fun under(vararg annotations: AnnotationFqn): DeclarationPredicate = UnderAnnotatedWith(annotations.toSet())
-fun has(vararg annotations: AnnotationFqn): DeclarationPredicate = AnnotatedWith(annotations.toSet())
+fun annotated(vararg annotations: AnnotationFqn): DeclarationPredicate = AnnotatedWith(annotations.toSet())
+fun parentAnnotated(vararg annotations: AnnotationFqn): DeclarationPredicate = ParentAnnotatedWith(annotations.toSet())
+fun hasAnnotated(vararg annotations: AnnotationFqn): DeclarationPredicate = HasAnnotatedWith(annotations.toSet())
+
 fun metaUnder(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = UnderMetaAnnotated(metaAnnotations.toSet())
-fun metaHas(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = AnnotatedWithMeta(metaAnnotations.toSet())
+fun metaAnnotated(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = AnnotatedWithMeta(metaAnnotations.toSet())
+fun parentMetaAnnotated(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = ParentMetaAnnotatedWith(metaAnnotations.toSet())
+fun hasMetaAnnotated(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = HasMetaAnnotatedWith(metaAnnotations.toSet())
 
-fun hasOrUnder(vararg annotations: AnnotationFqn): DeclarationPredicate = has(*annotations) or under(*annotations)
-fun metaHasOrUnder(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate = metaHas(*metaAnnotations) or metaUnder(*metaAnnotations)
+fun annotatedOrUnder(vararg annotations: AnnotationFqn): DeclarationPredicate = annotated(*annotations) or under(*annotations)
+fun metaAnnotatedOrUnder(vararg metaAnnotations: AnnotationFqn): DeclarationPredicate =
+    metaAnnotated(*metaAnnotations) or metaUnder(*metaAnnotations)
 
-// ------------------- colelctions -------------------
+// ------------------- collections -------------------
 fun under(annotations: Collection<AnnotationFqn>): DeclarationPredicate = UnderAnnotatedWith(annotations.toSet())
-fun has(annotations: Collection<AnnotationFqn>): DeclarationPredicate = AnnotatedWith(annotations.toSet())
-fun metaUnder(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = UnderMetaAnnotated(metaAnnotations.toSet())
-fun metaHas(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = AnnotatedWithMeta(metaAnnotations.toSet())
+fun annotated(annotations: Collection<AnnotationFqn>): DeclarationPredicate = AnnotatedWith(annotations.toSet())
+fun parentAnnotated(annotations: Collection<AnnotationFqn>): DeclarationPredicate = ParentAnnotatedWith(annotations.toSet())
+fun hasAnnotated(annotations: Collection<AnnotationFqn>): DeclarationPredicate = HasAnnotatedWith(annotations.toSet())
 
-fun hasOrUnder(annotations: Collection<AnnotationFqn>): DeclarationPredicate = has(annotations) or under(annotations)
-fun metaHasOrUnder(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = metaHas(metaAnnotations) or metaUnder(metaAnnotations)
+fun metaUnder(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = UnderMetaAnnotated(metaAnnotations.toSet())
+fun metaAnnotated(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = AnnotatedWithMeta(metaAnnotations.toSet())
+fun parentMetaAnnotated(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = ParentMetaAnnotatedWith(metaAnnotations.toSet())
+fun hasMetaAnnotated(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate = HasMetaAnnotatedWith(metaAnnotations.toSet())
+
+fun annotatedOrUnder(annotations: Collection<AnnotationFqn>): DeclarationPredicate = annotated(annotations) or under(annotations)
+fun metaAnnotatedOrUnder(metaAnnotations: Collection<AnnotationFqn>): DeclarationPredicate =
+    metaAnnotated(metaAnnotations) or metaUnder(metaAnnotations)

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

@@ -7,9 +7,6 @@ package org.jetbrains.kotlin.fir.extensions.predicate
 
 abstract class DeclarationPredicateVisitor<R, D> {
     abstract fun visitPredicate(predicate: DeclarationPredicate, data: D): R
-    open fun visitAny(predicate: DeclarationPredicate.Any, data: D): R {
-        return visitPredicate(predicate, data)
-    }
 
     open fun visitAnd(predicate: DeclarationPredicate.And, data: D): R {
         return visitPredicate(predicate, data)
@@ -31,6 +28,14 @@ abstract class DeclarationPredicateVisitor<R, D> {
         return visitAnnotated(predicate, data)
     }
 
+    open fun visitParentAnnotatedWith(predicate: ParentAnnotatedWith, data: D): R {
+        return visitAnnotated(predicate, data)
+    }
+
+    open fun visitHasAnnotatedWith(predicate: HasAnnotatedWith, data: D): R {
+        return visitAnnotated(predicate, data)
+    }
+
     open fun visitMetaAnnotated(predicate: MetaAnnotated, data: D): R {
         return visitPredicate(predicate, data)
     }
@@ -42,4 +47,12 @@ abstract class DeclarationPredicateVisitor<R, D> {
     open fun visitUnderMetaAnnotated(predicate: UnderMetaAnnotated, data: D): R {
         return visitMetaAnnotated(predicate, data)
     }
+
+    open fun visitParentMetaAnnotatedWith(predicate: ParentMetaAnnotatedWith, data: D): R {
+        return visitMetaAnnotated(predicate, data)
+    }
+
+    open fun visitHasMetaAnnotatedWith(predicate: HasMetaAnnotatedWith, data: D): R {
+        return visitMetaAnnotated(predicate, data)
+    }
 }

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

@@ -15,8 +15,8 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.extensions.FirExtensionSessionComponent.Factory
 import org.jetbrains.kotlin.fir.extensions.FirStatusTransformerExtension
-import org.jetbrains.kotlin.fir.extensions.predicate.has
-import org.jetbrains.kotlin.fir.extensions.predicate.metaHas
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
+import org.jetbrains.kotlin.fir.extensions.predicate.metaAnnotated
 import org.jetbrains.kotlin.fir.extensions.predicate.or
 import org.jetbrains.kotlin.fir.extensions.utils.AbstractSimpleClassPredicateMatchingService
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
@@ -59,7 +59,7 @@ class FirAllOpenPredicateMatcher(
 
     override val predicate = run {
         val annotationFqNames = allOpenAnnotationFqNames.map { FqName(it) }
-        has(annotationFqNames) or metaHas(annotationFqNames)
+        annotated(annotationFqNames) or metaAnnotated(annotationFqNames)
     }
 }
 

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

@@ -12,8 +12,8 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.FirStatusTransformerExtension
 import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
-import org.jetbrains.kotlin.fir.extensions.predicate.hasOrUnder
-import org.jetbrains.kotlin.fir.extensions.predicate.metaHasOrUnder
+import org.jetbrains.kotlin.fir.extensions.predicate.annotatedOrUnder
+import org.jetbrains.kotlin.fir.extensions.predicate.metaAnnotatedOrUnder
 import org.jetbrains.kotlin.fir.extensions.predicate.or
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.extensions.transform
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.name.FqName
 class AllOpenStatusTransformer(session: FirSession) : FirStatusTransformerExtension(session) {
     companion object {
         private val ALL_OPEN = FqName("org.jetbrains.kotlin.fir.plugin.AllOpen")
-        private val PREDICATE: DeclarationPredicate = hasOrUnder(ALL_OPEN) or metaHasOrUnder(ALL_OPEN)
+        private val PREDICATE: DeclarationPredicate = annotatedOrUnder(ALL_OPEN) or metaAnnotatedOrUnder(ALL_OPEN)
     }
 
     override fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus {

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.expressions.arguments
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.FirStatusTransformerExtension
 import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
-import org.jetbrains.kotlin.fir.extensions.predicate.hasOrUnder
+import org.jetbrains.kotlin.fir.extensions.predicate.annotatedOrUnder
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.extensions.transform
 import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -37,7 +37,7 @@ class AllPublicVisibilityTransformer(session: FirSession) : FirStatusTransformer
         private val PrivateName = Name.identifier("Private")
         private val ProtectedName = Name.identifier("Protected")
 
-        private val PREDICATE: DeclarationPredicate = hasOrUnder(AllPublicClassId.asSingleFqName())
+        private val PREDICATE: DeclarationPredicate = annotatedOrUnder(AllPublicClassId.asSingleFqName())
     }
 
     override fun transformStatus(status: FirDeclarationStatus, declaration: FirDeclaration): FirDeclarationStatus {

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

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.FirSupertypeGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
-import org.jetbrains.kotlin.fir.extensions.predicate.has
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.name.Name
 class SomeAdditionalSupertypeGenerator(session: FirSession) : FirSupertypeGenerationExtension(session) {
     companion object {
         private val myInterfaceClassId = ClassId(FqName("foo"), Name.identifier("MyInterface"))
-        private val PREDICATE: DeclarationPredicate = has("MyInterfaceSupertype".fqn())
+        private val PREDICATE: DeclarationPredicate = annotated("MyInterfaceSupertype".fqn())
 
     }
 

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

@@ -17,9 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusIm
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
-import org.jetbrains.kotlin.fir.extensions.predicate.has
-import org.jetbrains.kotlin.fir.extensions.predicate.metaHas
-import org.jetbrains.kotlin.fir.extensions.predicate.or
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.plugin.fqn
@@ -40,7 +38,7 @@ class AdditionalMembersGenerator(session: FirSession) : FirDeclarationGeneration
         private val MATERIALIZE_NAME = Name.identifier("materialize")
         private val NESTED_NAME = Name.identifier("Nested")
 
-        private val PREDICATE: DeclarationPredicate = has("NestedClassAndMaterializeMember".fqn())
+        private val PREDICATE: DeclarationPredicate = annotated("NestedClassAndMaterializeMember".fqn())
     }
 
     private val predicateBasedProvider = session.predicateBasedProvider

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

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
-import org.jetbrains.kotlin.fir.extensions.predicate.has
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.plugin.fqn
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.name.SpecialNames
  */
 class CompanionGenerator(session: FirSession) : FirDeclarationGenerationExtension(session) {
     companion object {
-        private val PREDICATE = has("CompanionWithFoo".fqn())
+        private val PREDICATE = annotated("CompanionWithFoo".fqn())
         private val FOO_NAME = Name.identifier("foo")
     }
 

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusIm
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
-import org.jetbrains.kotlin.fir.extensions.predicate.has
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.plugin.fqn
@@ -41,7 +41,7 @@ class ExternalClassGenerator(session: FirSession) : FirDeclarationGenerationExte
         private val GENERATED_CLASS_ID = ClassId(FOO_PACKAGE, Name.identifier("AllOpenGenerated"))
         private val MATERIALIZE_NAME = Name.identifier("materialize")
 
-        private val PREDICATE: DeclarationPredicate = has("ExternalClassWithNested".fqn())
+        private val PREDICATE: DeclarationPredicate = annotated("ExternalClassWithNested".fqn())
     }
 
     object Key : FirPluginKey() {

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusIm
 import org.jetbrains.kotlin.fir.expressions.builder.buildBlock
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
-import org.jetbrains.kotlin.fir.extensions.predicate.has
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.plugin.fqn
@@ -35,8 +35,8 @@ import org.jetbrains.kotlin.name.Name
  */
 class MembersOfSerializerGenerator(session: FirSession) : FirDeclarationGenerationExtension(session) {
     companion object {
-        private val SERIALIZABLE_PREDICATE = has("MySerializable".fqn())
-        private val CORE_SERIALIZER_PREDICATE = has("CoreSerializer".fqn())
+        private val SERIALIZABLE_PREDICATE = annotated("MySerializable".fqn())
+        private val CORE_SERIALIZER_PREDICATE = annotated("CoreSerializer".fqn())
 
         private val X_NAME = Name.identifier("x")
     }

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

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusIm
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
 import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
-import org.jetbrains.kotlin.fir.extensions.predicate.has
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.plugin.fqn
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name
  */
 class TopLevelDeclarationsGenerator(session: FirSession) : FirDeclarationGenerationExtension(session) {
     companion object {
-        private val PREDICATE: DeclarationPredicate = has("DummyFunction".fqn())
+        private val PREDICATE: DeclarationPredicate = annotated("DummyFunction".fqn())
     }
 
     private val predicateBasedProvider = session.predicateBasedProvider

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

@@ -6,17 +6,10 @@
 package org.jetbrains.kotlin.noarg.fir
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSessionComponent
-import org.jetbrains.kotlin.fir.caches.FirCache
-import org.jetbrains.kotlin.fir.caches.firCachesFactory
-import org.jetbrains.kotlin.fir.caches.getValue
-import org.jetbrains.kotlin.fir.extensions.predicate.has
-import org.jetbrains.kotlin.fir.extensions.predicate.metaHas
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
+import org.jetbrains.kotlin.fir.extensions.predicate.metaAnnotated
 import org.jetbrains.kotlin.fir.extensions.predicate.or
-import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.extensions.utils.AbstractSimpleClassPredicateMatchingService
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
 import org.jetbrains.kotlin.name.FqName
 
 class FirNoArgPredicateMatcher(
@@ -31,7 +24,7 @@ class FirNoArgPredicateMatcher(
 
     override val predicate = run {
         val annotationFqNames = noArgAnnotationFqNames.map { FqName(it) }
-        has(annotationFqNames) or metaHas(annotationFqNames)
+        annotated(annotationFqNames) or metaAnnotated(annotationFqNames)
     }
 }
 

plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/FirParcelizeDeclarationGenerator.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusIm
 import org.jetbrains.kotlin.fir.declarations.utils.modality
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationGenerationExtension
 import org.jetbrains.kotlin.fir.extensions.FirDeclarationPredicateRegistrar
-import org.jetbrains.kotlin.fir.extensions.predicate.has
+import org.jetbrains.kotlin.fir.extensions.predicate.annotated
 import org.jetbrains.kotlin.fir.extensions.predicateBasedProvider
 import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.resolve.defaultType
@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.utils.addToStdlib.runIf
 
 class FirParcelizeDeclarationGenerator(session: FirSession) : FirDeclarationGenerationExtension(session) {
     companion object {
-        private val PREDICATE = has(PARCELIZE_FQN, OLD_PARCELIZE_FQN)
+        private val PREDICATE = annotated(PARCELIZE_FQN, OLD_PARCELIZE_FQN)
         private val parcelizeMethodsNames = setOf(DESCRIBE_CONTENTS_NAME, WRITE_TO_PARCEL_NAME)
     }