diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt index 667764d306b..53708da74fd 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt +++ b/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) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProviderImpl.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProviderImpl.kt index 8c03496efae..5f678129635 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/extensions/FirPredicateBasedProviderImpl.kt +++ b/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) { 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 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): Boolean { - return cache.parentAnnotationsOfDeclaration[declaration].any { it in annotations } + return cache.annotationsOfUnderAnnotated[declaration].any { it in annotations } + } + + private fun matchParentWith(declaration: FirDeclaration, annotations: Set): Boolean { + return cache.annotationsOfParentAnnotated[declaration].any { it in annotations } + } + + private fun matchHasAnnotatedWith(declaration: FirDeclaration, annotations: Set): Boolean { + return cache.annotationsOfHasAnnotated[declaration].any { it in annotations } } } @@ -122,7 +160,13 @@ class FirPredicateBasedProviderImpl(private val session: FirSession) : FirPredic val annotationsOfDeclaration: LinkedHashMultimap = LinkedHashMultimap.create() val declarationsUnderAnnotated: Multimap = LinkedHashMultimap.create() - val parentAnnotationsOfDeclaration: LinkedHashMultimap = LinkedHashMultimap.create() + val annotationsOfUnderAnnotated: LinkedHashMultimap = LinkedHashMultimap.create() + + val declarationsParentAnnotated: Multimap = LinkedHashMultimap.create() + val annotationsOfParentAnnotated: Multimap = LinkedHashMultimap.create() + + val declarationsHasAnnotated: Multimap = LinkedHashMultimap.create() + val annotationsOfHasAnnotated: Multimap = LinkedHashMultimap.create() val ownersForDeclaration: MutableMap> = mutableMapOf() diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicate.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicate.kt index fae1020a3f7..8ce4ecc36d9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicate.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicate.kt @@ -15,17 +15,6 @@ sealed class DeclarationPredicate { abstract fun accept(visitor: DeclarationPredicateVisitor, data: D): R - object Any : DeclarationPredicate() { - override val annotations: Set - get() = emptySet() - override val metaAnnotations: Set - get() = emptySet() - - override fun accept(visitor: DeclarationPredicateVisitor, data: D): R { - return visitor.visitAny(this, data) - } - } - class Or(val a: DeclarationPredicate, val b: DeclarationPredicate) : DeclarationPredicate() { override val annotations: Set = a.annotations + b.annotations override val metaAnnotations: Set = 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) : DeclarationPredicate() { init { require(annotations.isNotEmpty()) { @@ -60,28 +55,109 @@ sealed class Annotated(final override val annotations: Set) : 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) : Annotated(annotations) { override fun accept(visitor: DeclarationPredicateVisitor, 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) : Annotated(annotations) { override fun accept(visitor: DeclarationPredicateVisitor, 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) : Annotated(annotations) { + override fun accept(visitor: DeclarationPredicateVisitor, 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) : Annotated(annotations) { + override fun accept(visitor: DeclarationPredicateVisitor, data: D): R { + return visitor.visitHasAnnotatedWith(this, data) + } +} + +// ------------------------------------ MetaAnnotated ------------------------------------ sealed class MetaAnnotated(final override val metaAnnotations: Set) : DeclarationPredicate() { init { @@ -110,6 +186,18 @@ class UnderMetaAnnotated(metaAnnotations: Set) : MetaAnnotated(me } } +class ParentMetaAnnotatedWith(metaAnnotations: Set) : MetaAnnotated(metaAnnotations) { + override fun accept(visitor: DeclarationPredicateVisitor, data: D): R { + return visitor.visitParentMetaAnnotatedWith(this, data) + } +} + +class HasMetaAnnotatedWith(metaAnnotations: Set) : MetaAnnotated(metaAnnotations) { + override fun accept(visitor: DeclarationPredicateVisitor, 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): DeclarationPredicate = UnderAnnotatedWith(annotations.toSet()) -fun has(annotations: Collection): DeclarationPredicate = AnnotatedWith(annotations.toSet()) -fun metaUnder(metaAnnotations: Collection): DeclarationPredicate = UnderMetaAnnotated(metaAnnotations.toSet()) -fun metaHas(metaAnnotations: Collection): DeclarationPredicate = AnnotatedWithMeta(metaAnnotations.toSet()) +fun annotated(annotations: Collection): DeclarationPredicate = AnnotatedWith(annotations.toSet()) +fun parentAnnotated(annotations: Collection): DeclarationPredicate = ParentAnnotatedWith(annotations.toSet()) +fun hasAnnotated(annotations: Collection): DeclarationPredicate = HasAnnotatedWith(annotations.toSet()) -fun hasOrUnder(annotations: Collection): DeclarationPredicate = has(annotations) or under(annotations) -fun metaHasOrUnder(metaAnnotations: Collection): DeclarationPredicate = metaHas(metaAnnotations) or metaUnder(metaAnnotations) +fun metaUnder(metaAnnotations: Collection): DeclarationPredicate = UnderMetaAnnotated(metaAnnotations.toSet()) +fun metaAnnotated(metaAnnotations: Collection): DeclarationPredicate = AnnotatedWithMeta(metaAnnotations.toSet()) +fun parentMetaAnnotated(metaAnnotations: Collection): DeclarationPredicate = ParentMetaAnnotatedWith(metaAnnotations.toSet()) +fun hasMetaAnnotated(metaAnnotations: Collection): DeclarationPredicate = HasMetaAnnotatedWith(metaAnnotations.toSet()) + +fun annotatedOrUnder(annotations: Collection): DeclarationPredicate = annotated(annotations) or under(annotations) +fun metaAnnotatedOrUnder(metaAnnotations: Collection): DeclarationPredicate = + metaAnnotated(metaAnnotations) or metaUnder(metaAnnotations) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicateVisitor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicateVisitor.kt index 8d83e158443..0a98448c8cd 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/extensions/predicate/DeclarationPredicateVisitor.kt +++ b/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 { 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 { 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 { 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) + } } diff --git a/plugins/allopen/allopen.k2/src/org/jetbrains/kotlin/allopen/fir/FirAllOpenStatusTransformer.kt b/plugins/allopen/allopen.k2/src/org/jetbrains/kotlin/allopen/fir/FirAllOpenStatusTransformer.kt index b26924ee934..d2e97afb1fc 100644 --- a/plugins/allopen/allopen.k2/src/org/jetbrains/kotlin/allopen/fir/FirAllOpenStatusTransformer.kt +++ b/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) } } diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt index afc4bb4e409..846e2d8beae 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllOpenStatusTransformer.kt +++ b/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 { diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt index 5e23006d46e..9366805b95d 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/AllPublicVisibilityTransformer.kt +++ b/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 { diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SomeAdditionalSupertypeGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SomeAdditionalSupertypeGenerator.kt index a30d570b6d6..e769e548be7 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/SomeAdditionalSupertypeGenerator.kt +++ b/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()) } diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AdditionalMembersGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AdditionalMembersGenerator.kt index b0fb047e026..44f80aa87e8 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AdditionalMembersGenerator.kt +++ b/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 diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/CompanionGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/CompanionGenerator.kt index b28600e1861..343706ad73a 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/CompanionGenerator.kt +++ b/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") } diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/ExternalClassGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/ExternalClassGenerator.kt index 397d7adb34a..a57351f619e 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/ExternalClassGenerator.kt +++ b/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() { diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/MembersOfSerializerGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/MembersOfSerializerGenerator.kt index def34a583e6..5625e9707e4 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/MembersOfSerializerGenerator.kt +++ b/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") } diff --git a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/TopLevelDeclarationsGenerator.kt b/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/TopLevelDeclarationsGenerator.kt index 78a6ae02b19..6267e74ded7 100644 --- a/plugins/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/TopLevelDeclarationsGenerator.kt +++ b/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 diff --git a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt b/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt index 4dade8a79a5..ee40afd1e08 100644 --- a/plugins/noarg/noarg.k2/src/org/jetbrains/kotlin/noarg/fir/NoArgAnnotationNameProvider.kt +++ b/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) } } diff --git a/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/FirParcelizeDeclarationGenerator.kt b/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/FirParcelizeDeclarationGenerator.kt index 3c25c439069..bda5ecf4fdd 100644 --- a/plugins/parcelize/parcelize-compiler/parcelize.k2/src/org/jetbrains/kotlin/parcelize/fir/FirParcelizeDeclarationGenerator.kt +++ b/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) }