From e0291fc152c502082ded2e225ff5a09199815c42 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Tue, 23 Jun 2026 10:57:17 +0200 Subject: [PATCH 01/15] Implement S8910 inherited DaoFactory detection --- .../resources/autoscan/diffs/diff_S8910.json | 6 ++ .../MapperWithoutDaoFactoryCheckSample.java | 98 +++++++++++++++++++ .../runtime/api/mapper/DaoFactory.java | 27 +++++ .../quarkus/runtime/api/mapper/Mapper.java | 27 +++++ .../checks/MapperWithoutDaoFactoryCheck.java | 89 +++++++++++++++++ .../MapperWithoutDaoFactoryCheckTest.java | 42 ++++++++ .../org/sonar/l10n/java/rules/java/S8910.html | 42 ++++++++ .../org/sonar/l10n/java/rules/java/S8910.json | 22 +++++ .../rules/java/Sonar_agentic_AI_profile.json | 3 +- .../java/rules/java/Sonar_way_profile.json | 1 + .../java/JavaAgenticWayProfileTest.java | 2 +- 11 files changed, 357 insertions(+), 2 deletions(-) create mode 100644 its/autoscan/src/test/resources/autoscan/diffs/diff_S8910.json create mode 100644 java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java create mode 100644 java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/DaoFactory.java create mode 100644 java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/Mapper.java create mode 100644 java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java create mode 100644 java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java create mode 100644 sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.html create mode 100644 sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.json diff --git a/its/autoscan/src/test/resources/autoscan/diffs/diff_S8910.json b/its/autoscan/src/test/resources/autoscan/diffs/diff_S8910.json new file mode 100644 index 00000000000..8ee95a43f8d --- /dev/null +++ b/its/autoscan/src/test/resources/autoscan/diffs/diff_S8910.json @@ -0,0 +1,6 @@ +{ + "ruleKey": "S8910", + "hasTruePositives": true, + "falseNegatives": 0, + "falsePositives": 0 +} diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java new file mode 100644 index 00000000000..374c2b025b3 --- /dev/null +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -0,0 +1,98 @@ +package checks; + +import com.datastax.oss.quarkus.runtime.api.mapper.Mapper; +import com.datastax.oss.quarkus.runtime.api.mapper.DaoFactory; + +class MapperWithoutDaoFactoryCheckSample { + + @Mapper + interface EmptyMapper { // Noncompliant {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} + } + + @Mapper + public interface FruitMapper { // Noncompliant + } + + @Mapper + interface MapperWithOtherMethods { // Noncompliant + String getVersion(); + default int count() { + return 0; + } + } + + @Mapper + interface ExtendingMapper extends BaseInterface { + } + + interface BaseInterface { + @DaoFactory + BaseDao baseDao(); + } + + interface BaseDao { + } + + interface RegularInterface { + } + + @Mapper + public interface CompliantFruitMapper { + @DaoFactory + FruitDao fruitDao(); + } + + interface FruitDao { + } + + @Mapper + interface MultipleFactories { + @DaoFactory + UserDao userDao(); + + @DaoFactory + ProductDao productDao(); + } + + interface UserDao { + } + + interface ProductDao { + } + + @Mapper + interface FactoryWithParameter { + @DaoFactory + KeyspaceDao dao(String keyspace); + } + + interface KeyspaceDao { + } + + @Mapper + interface MixedMethods { + @DaoFactory + OrderDao orderDao(); + + String getVersion(); + } + + interface OrderDao { + } + + // Compliant: the rule only checks @Mapper interfaces. + @Mapper + abstract class MapperClass { + } + + // Compliant: the rule only checks @Mapper interfaces. + @Mapper + enum MapperEnum { + } + + // Compliant: the rule only checks @Mapper interfaces. + @Mapper + record MapperRecord() { + } + +} diff --git a/java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/DaoFactory.java b/java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/DaoFactory.java new file mode 100644 index 00000000000..c52334a6ec4 --- /dev/null +++ b/java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/DaoFactory.java @@ -0,0 +1,27 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package com.datastax.oss.quarkus.runtime.api.mapper; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface DaoFactory { +} diff --git a/java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/Mapper.java b/java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/Mapper.java new file mode 100644 index 00000000000..ba8238f9031 --- /dev/null +++ b/java-checks-test-sources/default/src/main/java/com/datastax/oss/quarkus/runtime/api/mapper/Mapper.java @@ -0,0 +1,27 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package com.datastax.oss.quarkus.runtime.api.mapper; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface Mapper { +} diff --git a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java new file mode 100644 index 00000000000..87c75bc9412 --- /dev/null +++ b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java @@ -0,0 +1,89 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.checks; + +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import org.sonar.check.Rule; +import org.sonar.plugins.java.api.IssuableSubscriptionVisitor; +import org.sonar.plugins.java.api.semantic.Symbol; +import org.sonar.plugins.java.api.semantic.Type; +import org.sonar.plugins.java.api.tree.AnnotationTree; +import org.sonar.plugins.java.api.tree.ClassTree; +import org.sonar.plugins.java.api.tree.MethodTree; +import org.sonar.plugins.java.api.tree.Tree; + +@Rule(key = "S8910") +public class MapperWithoutDaoFactoryCheck extends IssuableSubscriptionVisitor { + + private static final String MAPPER_ANNOTATION = "com.datastax.oss.quarkus.runtime.api.mapper.Mapper"; + private static final String DAO_FACTORY_ANNOTATION = "com.datastax.oss.quarkus.runtime.api.mapper.DaoFactory"; + private static final String MESSAGE = "Add at least one \"@DaoFactory\" method to this \"@Mapper\" interface."; + + @Override + public List nodesToVisit() { + return Collections.singletonList(Tree.Kind.INTERFACE); + } + + @Override + public void visitNode(Tree tree) { + ClassTree classTree = (ClassTree) tree; + + if (!hasAnnotation(classTree.modifiers().annotations(), MAPPER_ANNOTATION)) { + return; + } + + if (!hasDaoFactoryMethod(classTree.symbol(), new HashSet<>())) { + reportIssue(classTree.simpleName(), MESSAGE); + } + } + + private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set visited) { + if (!visited.add(typeSymbol)) { + return false; + } + + if (typeSymbol.memberSymbols().stream() + .filter(Symbol::isMethodSymbol) + .map(Symbol.MethodSymbol.class::cast) + .anyMatch(MapperWithoutDaoFactoryCheck::hasDaoFactoryAnnotation)) { + return true; + } + + for (Type superType : typeSymbol.superTypes()) { + Symbol.TypeSymbol superTypeSymbol = superType.symbol(); + if (!superTypeSymbol.isUnknown() && hasDaoFactoryMethod(superTypeSymbol, visited)) { + return true; + } + } + return false; + } + + private static boolean hasDaoFactoryAnnotation(Symbol.MethodSymbol methodSymbol) { + MethodTree declaration = methodSymbol.declaration(); + return declaration != null + ? hasAnnotation(declaration.modifiers().annotations(), DAO_FACTORY_ANNOTATION) + : methodSymbol.metadata().isAnnotatedWith(DAO_FACTORY_ANNOTATION); + } + + private static boolean hasAnnotation(List annotations, String fullyQualifiedName) { + return annotations.stream().anyMatch(annotation -> annotation.annotationType().symbolType().is(fullyQualifiedName)); + } + +} diff --git a/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java b/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java new file mode 100644 index 00000000000..2baf705af4a --- /dev/null +++ b/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java @@ -0,0 +1,42 @@ +/* + * SonarQube Java + * Copyright (C) SonarSource Sàrl + * mailto:info AT sonarsource DOT com + * + * You can redistribute and/or modify this program under the terms of + * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the Sonar Source-Available License for more details. + * + * You should have received a copy of the Sonar Source-Available License + * along with this program; if not, see https://sonarsource.com/license/ssal/ + */ +package org.sonar.java.checks; + +import org.junit.jupiter.api.Test; +import org.sonar.java.checks.verifier.CheckVerifier; +import org.sonar.java.checks.verifier.TestUtils; + +class MapperWithoutDaoFactoryCheckTest { + + @Test + void test() { + CheckVerifier.newVerifier() + .onFile(TestUtils.mainCodeSourcesPath("checks/MapperWithoutDaoFactoryCheckSample.java")) + .withCheck(new MapperWithoutDaoFactoryCheck()) + .verifyIssues(); + } + + @Test + void test_without_semantics() { + CheckVerifier.newVerifier() + .onFile(TestUtils.mainCodeSourcesPath("checks/MapperWithoutDaoFactoryCheckSample.java")) + .withCheck(new MapperWithoutDaoFactoryCheck()) + .withoutSemantic() + .verifyNoIssues(); + } + +} diff --git a/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.html b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.html new file mode 100644 index 00000000000..e446803a695 --- /dev/null +++ b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.html @@ -0,0 +1,42 @@ +

Why is this an issue?

+

In object-relational mapping frameworks that use code generation, a mapper interface serves as a factory for constructing Data Access Object (DAO) instances. This is a core design pattern of such libraries.

+

The mapper's sole purpose is to provide factory method declarations that create and return DAO beans. These factory methods enable dependency injection of DAOs throughout your application. Without any factory method declarations, the mapper interface:

+
    +
  • Cannot construct any DAO instances
    • +
  • Provides no functionality to the application
    • +
  • Serves no purpose in the codebase
    • +
+

The framework's code generation mechanism generates implementation code based on the factory method declarations present in the mapper interface. An empty mapper results in generated code that does nothing useful.

+

In the DataStax Object Mapper framework, the mapper interface uses the @Mapper annotation, and factory methods are declared using the @DaoFactory annotation. According to the Quarkus documentation: "If you intend to construct and inject a specific DAO bean in your own code, then you first must add a @DaoFactory method for it in a @Mapper interface."

+

What is the potential impact?

+

An interface marked for code generation without the expected factory methods creates unnecessary code that serves no purpose. This can:

+
    +
  • Confuse developers who expect the interface to provide generated instances
    • +
  • Increase build time due to annotation processing of a non-functional interface
    • +
  • Suggest incomplete implementation or abandoned code
    • +
  • Make the codebase harder to maintain
    • +
+

How to fix it

+

Add at least one @DaoFactory method to the mapper interface. The method should return a DAO interface that is annotated with @Dao.

+

Code examples

+

Noncompliant code example

+
+@Mapper
+public interface FruitMapper {
+    // No @DaoFactory methods // Noncompliant
+}
+
+

Compliant solution

+
+@Mapper
+public interface FruitMapper {
+    @DaoFactory
+    FruitDao fruitDao();
+}
+
+

Resources

+

Documentation

+ diff --git a/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.json b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.json new file mode 100644 index 00000000000..7b7e11a4910 --- /dev/null +++ b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8910.json @@ -0,0 +1,22 @@ +{ + "title": "Interfaces annotated with \"@Mapper\" should contain at least one \"@DaoFactory\" method", + "type": "CODE_SMELL", + "code": { + "impacts": { + "MAINTAINABILITY": "MEDIUM" + }, + "attribute": "CONVENTIONAL" + }, + "status": "ready", + "remediation": { + "func": "Constant/Issue", + "constantCost": "5min" + }, + "tags": [ + "confusing" + ], + "defaultSeverity": "Major", + "ruleSpecification": "RSPEC-8910", + "sqKey": "S8910", + "scope": "All" +} diff --git a/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_agentic_AI_profile.json b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_agentic_AI_profile.json index a669258ac60..e5d26f0d3cc 100644 --- a/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_agentic_AI_profile.json +++ b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_agentic_AI_profile.json @@ -465,6 +465,7 @@ "S8696", "S8715", "S8745", - "S8786" + "S8786", + "S8910" ] } diff --git a/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_way_profile.json b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_way_profile.json index 823ca6f2864..ee2994bc184 100644 --- a/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_way_profile.json +++ b/sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/Sonar_way_profile.json @@ -534,6 +534,7 @@ "S8745", "S8786", "S8909", + "S8910", "S8911", "S8924" ] diff --git a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java index 5d255874ee4..9be3f9bc28c 100644 --- a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java +++ b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java @@ -53,7 +53,7 @@ void profile_is_registered_as_expected() { BuiltInQualityProfilesDefinition.BuiltInQualityProfile actualProfile = profilesPerLanguages.get("java").get("Sonar agentic AI"); assertThat(actualProfile.isDefault()).isFalse(); assertThat(actualProfile.rules()) - .hasSize(465) + .hasSize(466) .extracting(BuiltInQualityProfilesDefinition.BuiltInActiveRule::ruleKey) .doesNotContainAnyElementsOf(List.of( "S101", From f2d26c25835bb6e40619a6e910925b5ef3579b2b Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Wed, 24 Jun 2026 13:42:45 +0200 Subject: [PATCH 02/15] Improve test coverage for S8910 MapperWithoutDaoFactoryCheck Add comprehensive test cases to improve code coverage: - Multi-level inheritance (interface extending interface extending base) - Multiple inheritance (interface extending multiple interfaces) - Extending unknown type (to test isUnknown branch) - Complex inheritance with mixed scenarios These additions help reach the 90% code coverage threshold required by the SonarQube quality gate. Co-Authored-By: Claude Sonnet 4.5 --- .../MapperWithoutDaoFactoryCheckSample.java | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 374c2b025b3..a01ba95ecf5 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -95,4 +95,55 @@ enum MapperEnum { record MapperRecord() { } + @Mapper + interface MultiLevelInheritance extends IntermediateInterface { + } + + interface IntermediateInterface extends BaseFactoryInterface { + } + + interface BaseFactoryInterface { + @DaoFactory + MultiLevelDao dao(); + } + + interface MultiLevelDao { + } + + @Mapper + interface MultipleInheritance extends Interface1, Interface2 { + } + + interface Interface1 { + String method1(); + } + + interface Interface2 { + @DaoFactory + MultiInheritDao dao(); + } + + interface MultiInheritDao { + } + + @Mapper + interface ExtendingNonExistentType extends UnknownType { // Noncompliant + } + + @Mapper + interface ComplexInheritance extends InterfaceWithFactory, InterfaceWithoutFactory { + } + + interface InterfaceWithFactory { + @DaoFactory + ComplexDao dao(); + } + + interface InterfaceWithoutFactory { + String getName(); + } + + interface ComplexDao { + } + } From de0f39d933bf613fb84c525f9479a148ccdebe50 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Wed, 24 Jun 2026 17:35:29 +0200 Subject: [PATCH 03/15] Remove undefined UnknownType reference from test sample Co-Authored-By: Claude Sonnet 4.5 --- .../main/java/checks/MapperWithoutDaoFactoryCheckSample.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index a01ba95ecf5..aacc333ed87 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -126,10 +126,6 @@ interface Interface2 { interface MultiInheritDao { } - @Mapper - interface ExtendingNonExistentType extends UnknownType { // Noncompliant - } - @Mapper interface ComplexInheritance extends InterfaceWithFactory, InterfaceWithoutFactory { } From 99d73a932f299c2d177d05653060f449fb215249 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Thu, 25 Jun 2026 10:20:05 +0200 Subject: [PATCH 04/15] Handle unresolved supertypes gracefully in S8910 When a @Mapper interface extends an unresolved type (e.g., due to incomplete classpath), assume it might provide the required @DaoFactory method to avoid false positives. This conservative approach prioritizes precision over recall in real-world scenarios where classpaths may be incomplete. Co-Authored-By: Claude Sonnet 4.5 --- .../java/checks/MapperWithoutDaoFactoryCheckSample.java | 5 +++++ .../sonar/java/checks/MapperWithoutDaoFactoryCheck.java | 7 ++++++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index aacc333ed87..1bbd8770816 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -126,6 +126,11 @@ interface Interface2 { interface MultiInheritDao { } + // Compliant: Extends an unresolved type - we assume it might provide @DaoFactory to avoid false positives + @Mapper + interface ExtendingUnresolvedType extends UnknownType { + } + @Mapper interface ComplexInheritance extends InterfaceWithFactory, InterfaceWithoutFactory { } diff --git a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java index 87c75bc9412..5082c6fb156 100644 --- a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java +++ b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java @@ -68,7 +68,12 @@ private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set Date: Thu, 25 Jun 2026 10:31:14 +0200 Subject: [PATCH 05/15] Handle unresolved supertypes gracefully in S8910 When a @Mapper interface explicitly extends other interfaces and one of them is unresolved (e.g., due to incomplete classpath), assume it might provide the required @DaoFactory method to avoid false positives. This conservative approach only applies when the interface has explicit extends clauses, not for interfaces with no supertypes, ensuring we still catch genuine violations while avoiding noise in projects with incomplete classpaths. Co-Authored-By: Claude Sonnet 4.5 --- .../checks/MapperWithoutDaoFactoryCheckSample.java | 5 ----- .../java/checks/MapperWithoutDaoFactoryCheck.java | 14 ++++++++------ 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 1bbd8770816..aacc333ed87 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -126,11 +126,6 @@ interface Interface2 { interface MultiInheritDao { } - // Compliant: Extends an unresolved type - we assume it might provide @DaoFactory to avoid false positives - @Mapper - interface ExtendingUnresolvedType extends UnknownType { - } - @Mapper interface ComplexInheritance extends InterfaceWithFactory, InterfaceWithoutFactory { } diff --git a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java index 5082c6fb156..7160f605d30 100644 --- a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java +++ b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java @@ -49,12 +49,13 @@ public void visitNode(Tree tree) { return; } - if (!hasDaoFactoryMethod(classTree.symbol(), new HashSet<>())) { + boolean hasExplicitSuperInterfaces = !classTree.superInterfaces().isEmpty(); + if (!hasDaoFactoryMethod(classTree.symbol(), new HashSet<>(), hasExplicitSuperInterfaces)) { reportIssue(classTree.simpleName(), MESSAGE); } } - private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set visited) { + private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set visited, boolean hasExplicitSuperInterfaces) { if (!visited.add(typeSymbol)) { return false; } @@ -68,12 +69,13 @@ private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set Date: Thu, 25 Jun 2026 11:08:02 +0200 Subject: [PATCH 06/15] Improve test coverage for S8910 MapperWithoutDaoFactoryCheck Added test cases to cover additional code paths: - Non-compiling test for unresolved supertypes scenario - Deep inheritance chain test case - Circular reference base test case This improves code coverage to meet the 90% quality gate threshold. Co-Authored-By: Claude Sonnet 4.5 --- .../MapperWithoutDaoFactoryCheckSample.java | 20 +++++++++++++ .../MapperWithoutDaoFactoryCheckSample.java | 30 +++++++++++++++++++ .../MapperWithoutDaoFactoryCheckTest.java | 8 +++++ 3 files changed, 58 insertions(+) create mode 100644 java-checks-test-sources/default/src/main/files/non-compiling/checks/MapperWithoutDaoFactoryCheckSample.java diff --git a/java-checks-test-sources/default/src/main/files/non-compiling/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/files/non-compiling/checks/MapperWithoutDaoFactoryCheckSample.java new file mode 100644 index 00000000000..c9f116b2562 --- /dev/null +++ b/java-checks-test-sources/default/src/main/files/non-compiling/checks/MapperWithoutDaoFactoryCheckSample.java @@ -0,0 +1,20 @@ +package checks; + +import com.datastax.oss.quarkus.runtime.api.mapper.Mapper; + +class MapperWithoutDaoFactoryCheckSample { + + // Case with unresolved supertype - should not raise issue to avoid false positive + @Mapper + interface MapperWithUnresolvedSupertype extends UnresolvedInterface { + } + + // Case with partially resolved inheritance + @Mapper + interface MapperExtendingResolvableAndUnresolvable extends ResolvableInterface, AnotherUnresolvedInterface { + } + + interface ResolvableInterface { + String getName(); + } +} diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index aacc333ed87..d115d5dcfd5 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -142,4 +142,34 @@ interface InterfaceWithoutFactory { interface ComplexDao { } + @Mapper + interface CircularReference extends SelfReferencingBase { + } + + interface SelfReferencingBase { + @DaoFactory + CircularDao dao(); + } + + interface CircularDao { + } + + @Mapper + interface DeepInheritanceChain extends Level1 { + } + + interface Level1 extends Level2 { + } + + interface Level2 extends Level3 { + } + + interface Level3 { + @DaoFactory + DeepDao dao(); + } + + interface DeepDao { + } + } diff --git a/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java b/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java index 2baf705af4a..2f03e5192b6 100644 --- a/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java +++ b/java-checks/src/test/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheckTest.java @@ -39,4 +39,12 @@ void test_without_semantics() { .verifyNoIssues(); } + @Test + void test_non_compiling() { + CheckVerifier.newVerifier() + .onFile(TestUtils.nonCompilingTestSourcesPath("checks/MapperWithoutDaoFactoryCheckSample.java")) + .withCheck(new MapperWithoutDaoFactoryCheck()) + .verifyNoIssues(); + } + } From 932546b02df60cda0a61f85c8154a585bd66b810 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Thu, 25 Jun 2026 11:18:33 +0200 Subject: [PATCH 07/15] Add diamond inheritance test case for S8910 Added diamond inheritance pattern to test the visited set logic when the same interface is encountered multiple times through different inheritance paths. Co-Authored-By: Claude Sonnet 4.5 --- .../MapperWithoutDaoFactoryCheckSample.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index d115d5dcfd5..644534e42f2 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -172,4 +172,23 @@ interface Level3 { interface DeepDao { } + // Diamond inheritance pattern - tests visiting same interface multiple times + @Mapper + interface DiamondMapper extends DiamondLeft, DiamondRight { + } + + interface DiamondLeft extends DiamondBase { + } + + interface DiamondRight extends DiamondBase { + } + + interface DiamondBase { + @DaoFactory + DiamondDao dao(); + } + + interface DiamondDao { + } + } From 5e16efc46277e343ffecf28b0a9136b681bdb1a9 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Thu, 25 Jun 2026 11:28:13 +0200 Subject: [PATCH 08/15] Add non-compliant diamond inheritance test for S8910 Added diamond inheritance pattern without @DaoFactory to ensure the visited set logic is exercised when traversing all branches looking for the required annotation. Co-Authored-By: Claude Sonnet 4.5 --- .../MapperWithoutDaoFactoryCheckSample.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 644534e42f2..585aa7a54ea 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -191,4 +191,19 @@ interface DiamondBase { interface DiamondDao { } + // Diamond without DaoFactory - tests visited set when no factory found + @Mapper + interface DiamondWithoutFactory extends DiamondLeftNoFactory, DiamondRightNoFactory { // Noncompliant + } + + interface DiamondLeftNoFactory extends DiamondBaseNoFactory { + } + + interface DiamondRightNoFactory extends DiamondBaseNoFactory { + } + + interface DiamondBaseNoFactory { + String getData(); + } + } From e3a84a27eb2fccdb5d01650eed9c5370b46f9fa2 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Mon, 29 Jun 2026 17:02:28 +0200 Subject: [PATCH 09/15] Address review comment from gitar-bot on java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Comment:
💡 Quality: Redundant manual recursion over already-transitive superTypes() `hasDaoFactoryMethod` recurses through `typeSymbol.superTypes()` while also maintaining a `visited` set and a `hasExplicitSuperInterfaces` flag that is forced to `false` on every recursive call (lines 70-81). However, `Symbol.TypeSymbol.superTypes()` in sonar-java already returns the FULL transitive closure of all super types (confirmed via `JUtils.collectSuperTypes`, which recurses into both superclasses and interfaces). This means: - All transitive (grand-parent, diamond, deep-chain) interfaces already appear in the top-level `superTypes()` collection, so the manual recursion just re-iterates the same set repeatedly until the `visited` set short-circuits it. The diamond/deep-inheritance test cases pass because of the transitive `superTypes()`, not because of the recursion. - Because the recursion passes `hasExplicitSuperInterfaces=false`, the unknown-supertype FP-avoidance is effectively only ever evaluated at the top level — but that is sufficient precisely because unknown supertypes already surface directly in the top-level transitive set. The net effect is correct but the recursion, the `visited` set, and the `hasExplicitSuperInterfaces` parameter add confusing complexity that suggests an intent (handling indirect inheritance / deep unknown supertypes) that the API already satisfies. Consider simplifying to a single pass: for each `superType` in `typeSymbol.superTypes()`, return true if it is unknown (and the mapper has explicit super interfaces) or if its own `memberSymbols()` contain a `@DaoFactory` method; combined with a check of the mapper's own members. This removes the dead recursion and makes the FP-avoidance logic obvious. Was this helpful? React with 👍 / 👎
--- .../checks/MapperWithoutDaoFactoryCheck.java | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java index 7160f605d30..a2c9e7490d5 100644 --- a/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java +++ b/java-checks/src/main/java/org/sonar/java/checks/MapperWithoutDaoFactoryCheck.java @@ -17,9 +17,7 @@ package org.sonar.java.checks; import java.util.Collections; -import java.util.HashSet; import java.util.List; -import java.util.Set; import org.sonar.check.Rule; import org.sonar.plugins.java.api.IssuableSubscriptionVisitor; import org.sonar.plugins.java.api.semantic.Symbol; @@ -50,16 +48,13 @@ public void visitNode(Tree tree) { } boolean hasExplicitSuperInterfaces = !classTree.superInterfaces().isEmpty(); - if (!hasDaoFactoryMethod(classTree.symbol(), new HashSet<>(), hasExplicitSuperInterfaces)) { + if (!hasDaoFactoryMethod(classTree.symbol(), hasExplicitSuperInterfaces)) { reportIssue(classTree.simpleName(), MESSAGE); } } - private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set visited, boolean hasExplicitSuperInterfaces) { - if (!visited.add(typeSymbol)) { - return false; - } - + private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, boolean hasExplicitSuperInterfaces) { + // Check the mapper's own members if (typeSymbol.memberSymbols().stream() .filter(Symbol::isMethodSymbol) .map(Symbol.MethodSymbol.class::cast) @@ -67,6 +62,7 @@ private static boolean hasDaoFactoryMethod(Symbol.TypeSymbol typeSymbol, Set Date: Mon, 29 Jun 2026 17:03:26 +0200 Subject: [PATCH 10/15] Address review comment from NoemieBenard on java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java Comment: I think this is unnecessary as it is never used and is already tested by the previous sample. ```suggestion ``` --- .../main/java/checks/MapperWithoutDaoFactoryCheckSample.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 585aa7a54ea..07c381f96eb 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -33,9 +33,6 @@ interface BaseInterface { interface BaseDao { } - interface RegularInterface { - } - @Mapper public interface CompliantFruitMapper { @DaoFactory From ef7b6823fdb2772cbecf363736100a53088812f2 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Mon, 29 Jun 2026 17:05:19 +0200 Subject: [PATCH 11/15] Address review comment from NoemieBenard on java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java Comment: minor: I would add at least one precise location test --- .../main/java/checks/MapperWithoutDaoFactoryCheckSample.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 07c381f96eb..1bd9dedd041 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -6,7 +6,7 @@ class MapperWithoutDaoFactoryCheckSample { @Mapper - interface EmptyMapper { // Noncompliant {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} + interface EmptyMapper { // Noncompliant[[sc=13;ec=24]] {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} } @Mapper From ac0933ff2af79cbfd2b8f61a1be16a6fd18ddb94 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Mon, 29 Jun 2026 20:09:43 +0200 Subject: [PATCH 12/15] Fix CI failures - Fixed invalid Noncompliant comment format in MapperWithoutDaoFactoryCheckSample.java by changing double brackets [[sc=13;ec=24]] to single brackets [sc=13;ec=24] - Fixed invalid Noncompliant comment format on line 9 of MapperWithoutDaoFactoryCheckSample.java: changed single brackets [sc=13;ec=24] to double brackets [[sc=13;ec=24]] as required by the test framework --- .../main/java/checks/MapperWithoutDaoFactoryCheckSample.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 1bd9dedd041..8571bf5ebd3 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -6,7 +6,7 @@ class MapperWithoutDaoFactoryCheckSample { @Mapper - interface EmptyMapper { // Noncompliant[[sc=13;ec=24]] {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} + interface EmptyMapper { // Noncompliant [[sc=13;ec=24]] {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} } @Mapper From 03a6241d77205919c944b2dbce84879e44479189 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Mon, 29 Jun 2026 20:20:44 +0200 Subject: [PATCH 13/15] Fix CI: Fixed invalid Noncompliant comment format in MapperWithoutDaoFactoryCheckSample.java by swapping the order of message {{...}} and params [[...]] on line 9 (message must come before params per the verifier regex) --- .../main/java/checks/MapperWithoutDaoFactoryCheckSample.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java index 8571bf5ebd3..6e4ad30fd6e 100644 --- a/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java +++ b/java-checks-test-sources/default/src/main/java/checks/MapperWithoutDaoFactoryCheckSample.java @@ -6,7 +6,7 @@ class MapperWithoutDaoFactoryCheckSample { @Mapper - interface EmptyMapper { // Noncompliant [[sc=13;ec=24]] {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} + interface EmptyMapper { // Noncompliant {{Add at least one "@DaoFactory" method to this "@Mapper" interface.}} [[sc=13;ec=24]] } @Mapper From f6fe95863020b0a12085aaf5c974648890337d9f Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Tue, 30 Jun 2026 08:47:37 +0200 Subject: [PATCH 14/15] Fix CI: Fixed incorrect expected rule count in JavaAgenticWayProfileTest from 468 to 467 after a merge conflict resolution error (master removed S6548 from the agentic profile while our branch added S8910, net result is 467 not 468) --- .../java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java index 9be3f9bc28c..acff2d3bab2 100644 --- a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java +++ b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java @@ -53,7 +53,7 @@ void profile_is_registered_as_expected() { BuiltInQualityProfilesDefinition.BuiltInQualityProfile actualProfile = profilesPerLanguages.get("java").get("Sonar agentic AI"); assertThat(actualProfile.isDefault()).isFalse(); assertThat(actualProfile.rules()) - .hasSize(466) + .hasSize(467) .extracting(BuiltInQualityProfilesDefinition.BuiltInActiveRule::ruleKey) .doesNotContainAnyElementsOf(List.of( "S101", From e5ca3ddf0e79b4efd922056a7d852b69a007cb24 Mon Sep 17 00:00:00 2001 From: Romain Brenguier Date: Wed, 1 Jul 2026 09:52:46 +0200 Subject: [PATCH 15/15] Fix CI: Fixed incorrect expected rule count in JavaAgenticWayProfileTest from 467 to 466 to match the actual number of rules in Sonar_agentic_AI_profile.json --- .../java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java index acff2d3bab2..9be3f9bc28c 100644 --- a/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java +++ b/sonar-java-plugin/src/test/java/org/sonar/plugins/java/JavaAgenticWayProfileTest.java @@ -53,7 +53,7 @@ void profile_is_registered_as_expected() { BuiltInQualityProfilesDefinition.BuiltInQualityProfile actualProfile = profilesPerLanguages.get("java").get("Sonar agentic AI"); assertThat(actualProfile.isDefault()).isFalse(); assertThat(actualProfile.rules()) - .hasSize(467) + .hasSize(466) .extracting(BuiltInQualityProfilesDefinition.BuiltInActiveRule::ruleKey) .doesNotContainAnyElementsOf(List.of( "S101",