getAnnotations & getAllRawInterfaces falsely return empty lists

[thodorispa]

Hello everyone,
I am developing a test to detect unreferenced classes and i have encountered this issue.
I've defined two DescribedPredicate instances for JavaClass objects:

Implementing Interfaces Check: This predicate checks if a class implements any interfaces.
Matching Annotations Check: This predicate verifies if a class's methods are annotated with any annotations from a predefined list (e.g., @EventListener).
These predicates have worked well across most of my project, effectively flagging classes that are not directly referenced or are potentially redundant. However, I've noticed some anomalies where certain classes are incorrectly marked as unreferenced. Specifically:

• A service class that clearly implements an interface is not recognized by the getAllRawInterfaces method, which unexpectedly returns an empty set.
• Another class that contains methods annotated with @EventListener doesn't seem to be detected by the getAnnotations method, which also returns empty contrary to expectations.
• An entity having these annotations: @Entity, @Getter, @Table, @DynamicUpdate

I'm puzzled by these false negatives and would greatly appreciate any advice on why these methods might not be returning the expected results. Is there a known limitation or a specific scenario under which getAllRawInterfaces and getAnnotations might fail to detect existing interfaces and annotations?
Thank you in advance for your help and insights!

DescribedPredicate<JavaClass> implementingAnyInterfaces =
            new DescribedPredicate<>("implementing any interfaces") {
                @Override
                public boolean test(JavaClass clazz) {
                    return !clazz.getAllRawInterfaces().isEmpty();
                }
            };

DescribedPredicate<? super JavaClass> classHasMethodWithAnnotations(List<Class<? extends Annotation>> annotations) {
        return new DescribedPredicate<>("have annotations") {
            @Override
            public boolean test(JavaClass input) {
                return input.getMethods().stream().anyMatch(method ->
                        annotations.stream().anyMatch(annotation ->
                                method.isAnnotatedWith(annotation) || method.isMetaAnnotatedWith(annotation)));
            }
        };
    }

 ArchRule classesShouldNotBeUnused = classes()
            .that(not(implementingAnyInterfaces))
            .and(not(classHasMethodWithAnnotations(METHOD_ANNOTATIONS)))
            .should(shouldBeReferencedClass)

 private static final ArchCondition<JavaClass> shouldBeReferencedClass = new ArchCondition<>("not be unreferenced") {
        @Override
        public void check(JavaClass javaClass, ConditionEvents events) {

            Set<JavaAccess<?>> accesses = new HashSet<>(javaClass.getAccessesToSelf());
            accesses.removeAll(javaClass.getAccessesFromSelf());
            if (accesses.isEmpty() && javaClass.getDirectDependenciesToSelf().isEmpty()) {
                events.add(new SimpleConditionEvent(
                        javaClass,
                        false,
                        String.format(
                                "%s is unreferenced in %s",
                                javaClass.getDescription(), javaClass.getSourceCodeLocation())));
            }
        }
    };

[nbrugger-tgm]

Hi i dont know the mentioned annotation but it might be due to it not being retained in runtime?
Just a quick idea worth checking since archunit can only detect annotations that are retained at runtime

[thodorispa]

Thanks a lot for your suggestion although all the annotations mentioned are retained in runtime, also the mentioned predicates work for some of the classes using the annotations.

[codecholeric]

I would check if the classes that puzzle you are really directly imported. I.e. are those classes that the ClassFileImporter picked up directly from the classpath, etc., or if those were classes that were loaded later on because they were referenced by classes that were imported without being directly imported themselves (compare https://www.archunit.org/userguide/html/000_Index.html#_dealing_with_missing_classes)

You can either check the trace logs by hooking into Slf4j, or check JavaClass.isFullyImported() on the objects themselves. If the latter returns false, then that's likely the problem, i.e. ArchUnit just creating a stub but not importing the full class.