Implement new rule S8908

This rule detects methods annotated with @CacheResult that return void.
Since void methods have no return value to cache, applying @CacheResult
to them is meaningless and indicates a misunderstanding of how caching works.

Author: romainbrenguier

java-checks-test-sources/default/src/main/files/non-compiling/checks/QuarkusCacheResultOnVoidMethodCheckSample.java

@@ -0,0 +1,21 @@
+package checks;
+
+import io.quarkus.cache.CacheResult;
+
+public class QuarkusCacheResultOnVoidMethodCheckSample {
+
+  @CacheResult(cacheName = "my-cache")
+  public void processData(UnknownType key) { // Noncompliant
+  }
+
+  @CacheResult(cacheName = "my-cache")
+  public UnknownType getData(String key) { // Compliant - unknown return type, cannot determine if void
+  }
+
+  @CacheResult(cacheName = "my-cache")
+  public unknownReturnType computeValue(String input) { // Compliant - unknown return type
+  }
+
+  public void methodWithoutAnnotation(UnknownType param) { // Compliant
+  }
+}

java-checks-test-sources/default/src/main/java/checks/QuarkusCacheResultOnVoidMethodCheckSample.java

@@ -0,0 +1,79 @@
+package checks;
+
+import io.quarkus.cache.CacheInvalidate;
+import io.quarkus.cache.CacheInvalidateAll;
+import io.quarkus.cache.CacheResult;
+import java.util.List;
+import java.util.Optional;
+
+public class QuarkusCacheResultOnVoidMethodCheckSample {
+
+  @CacheResult(cacheName = "my-cache")
+  public void processData(String key) { // Noncompliant {{Methods annotated with "@CacheResult" should not return void.}}
+//       ^^^^
+  }
+
+  @CacheResult(cacheName = "calc-cache", lockTimeout = 1000)
+  public void performCalculation(String input) { // Noncompliant
+  }
+
+  @CacheResult(cacheName = "cache")
+  void packagePrivateVoid(String data) { // Noncompliant
+  }
+
+  @CacheResult(cacheName = "cache")
+  protected void protectedVoid() { // Noncompliant
+  }
+
+  @CacheResult(cacheName = "cache")
+  private void privateVoid(int value) { // Noncompliant
+  }
+
+  @CacheResult(cacheName = "my-cache")
+  public String getData(String key) { // Compliant
+    return "result-" + key;
+  }
+
+  @CacheResult(cacheName = "user-cache")
+  public User getUser(Long userId) { // Compliant
+    return new User();
+  }
+
+  @CacheResult(cacheName = "int-cache")
+  public Integer calculate(String input) { // Compliant
+    return input.length();
+  }
+
+  @CacheResult(cacheName = "optional-cache")
+  public Optional<String> findValue(String key) { // Compliant
+    return Optional.empty();
+  }
+
+  @CacheResult(cacheName = "list-cache")
+  public List<String> getList(String item) { // Compliant
+    return List.of(item);
+  }
+
+  @CacheResult(cacheName = "array-cache")
+  public String[] getArray() { // Compliant
+    return new String[]{"a", "b"};
+  }
+
+  public void voidMethodNoAnnotation(String key) { // Compliant
+  }
+
+  @CacheInvalidate(cacheName = "my-cache")
+  public void invalidateCache(String key) { // Compliant
+  }
+
+  @CacheInvalidateAll(cacheName = "my-cache")
+  public void clearCache() { // Compliant
+  }
+
+  public String methodNoAnnotation(String input) { // Compliant
+    return input;
+  }
+
+  private static class User {
+  }
+}

java-checks/src/main/java/org/sonar/java/checks/QuarkusCacheResultOnVoidMethodCheck.java

@@ -0,0 +1,62 @@
+/*
+ * 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.List;
+import java.util.Optional;
+import java.util.function.Function;
+import org.sonar.check.Rule;
+import org.sonar.plugins.java.api.DependencyVersionAware;
+import org.sonar.plugins.java.api.IssuableSubscriptionVisitor;
+import org.sonar.plugins.java.api.Version;
+import org.sonar.plugins.java.api.semantic.Type;
+import org.sonar.plugins.java.api.tree.MethodTree;
+import org.sonar.plugins.java.api.tree.Tree;
+import org.sonar.plugins.java.api.tree.TypeTree;
+
+@Rule(key = "S8908")
+public class QuarkusCacheResultOnVoidMethodCheck extends IssuableSubscriptionVisitor implements DependencyVersionAware {
+
+  private static final String CACHE_RESULT_ANNOTATION = "io.quarkus.cache.CacheResult";
+
+  @Override
+  public List<Tree.Kind> nodesToVisit() {
+    return List.of(Tree.Kind.METHOD);
+  }
+
+  @Override
+  public void visitNode(Tree tree) {
+    var mt = (MethodTree) tree;
+    if (mt.symbol().metadata().isAnnotatedWith(CACHE_RESULT_ANNOTATION)) {
+      TypeTree returnType = mt.returnType();
+      // returnType can only be null if the method is a constructor. Since the @CacheResult annotation is not allowed on constructors, and since
+      // we hence only visit methods, not constructors, we assume that returnType is not null.
+      Type symbolType = returnType.symbolType();
+      if (symbolType.isUnknown()) {
+        return;
+      }
+      if (symbolType.isVoid()) {
+        reportIssue(returnType, "Methods annotated with \"@CacheResult\" should not return void.");
+      }
+    }
+  }
+
+  @Override
+  public boolean isCompatibleWithDependencies(Function<String, Optional<Version>> dependencyFinder) {
+    return dependencyFinder.apply("quarkus-cache").isPresent();
+  }
+}

java-checks/src/test/java/org/sonar/java/checks/QuarkusCacheResultOnVoidMethodCheckTest.java

@@ -0,0 +1,41 @@
+/*
+ * 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 static org.sonar.java.checks.verifier.TestUtils.mainCodeSourcesPath;
+import static org.sonar.java.checks.verifier.TestUtils.nonCompilingTestSourcesPath;
+
+class QuarkusCacheResultOnVoidMethodCheckTest {
+  @Test
+  void test() {
+    CheckVerifier.newVerifier()
+      .onFile(mainCodeSourcesPath("checks/QuarkusCacheResultOnVoidMethodCheckSample.java"))
+      .withCheck(new QuarkusCacheResultOnVoidMethodCheck())
+      .verifyIssues();
+  }
+
+  @Test
+  void test_non_compiling() {
+    CheckVerifier.newVerifier()
+      .onFile(nonCompilingTestSourcesPath("checks/QuarkusCacheResultOnVoidMethodCheckSample.java"))
+      .withCheck(new QuarkusCacheResultOnVoidMethodCheck())
+      .verifyIssues();
+  }
+}

sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8908.html

@@ -0,0 +1,44 @@
+<h2>Why is this an issue?</h2>
+<p>Return value caching annotations are designed to cache the output of a method. When a method annotated for result caching is invoked, the framework computes a cache key and checks if the result has been previously cached. If found, the cached value is returned without executing the method body. If not found, the method executes and its return value is stored in the cache.</p>
+<p>This caching mechanism fundamentally requires a return value to function. A <code>void</code> method, by definition, does not return a value - it only produces side effects. Since there is no value to cache or retrieve, applying result caching annotations to a void method is meaningless and will not provide any caching benefits.</p>
+<p>This misuse typically indicates one of the following:</p>
+<ul>
+  <li>A misunderstanding of how result caching works</li>
+  <li>An attempt to cache side effects, which is not supported by these annotations</li>
+  <li>A method that should be refactored to return a value if caching is truly needed</li>
+</ul>
+<p>Framework documentation explicitly states that result caching annotations cannot be used on methods returning <code>void</code>.</p>
+<h2>What is the potential impact?</h2>
+<p>While this issue does not cause runtime errors or security vulnerabilities, it can lead to:</p>
+<ul>
+  <li>Confusion about the intended behavior of the code</li>
+  <li>Wasted developer time investigating why caching is not working as expected</li>
+  <li>Maintenance overhead from unnecessary annotations that serve no purpose</li>
+  <li>Potential performance misconceptions if developers believe expensive operations are being cached when they are not</li>
+</ul>
+<h2>How to fix it</h2>
+<p>Remove the <code>@CacheResult</code> annotation from the void method if caching is not needed, or refactor the method to return a value that can be meaningfully cached.</p>
+<h3>Code examples</h3>
+<h4>Noncompliant code example</h4>
+<pre data-diff-id="1" data-diff-type="noncompliant">
+@CacheResult(cacheName = "my-cache")
+public void processData(String key) { // Noncompliant
+    // Process expensive data
+    expensiveService.process(key);
+}
+</pre>
+<h4>Compliant solution</h4>
+<pre data-diff-id="1" data-diff-type="compliant">
+@CacheResult(cacheName = "my-cache")
+public String processData(String key) {
+    // Process expensive data and return result
+    String result = expensiveService.process(key);
+    return result;
+}
+</pre>
+<h2>Resources</h2>
+<h3>Documentation</h3>
+<ul>
+  <li>Quarkus Cache Guide - <a href="https://quarkus.io/guides/cache">Official Quarkus documentation on application data caching, including proper usage of @CacheResult annotation</a></li>
+  <li>Quarkus @CacheResult Annotation Reference - <a href="https://quarkus.io/guides/cache#cacheresult">Detailed reference for the @CacheResult annotation, explicitly noting it cannot be used on void methods</a></li>
+</ul>

sonar-java-plugin/src/main/resources/org/sonar/l10n/java/rules/java/S8908.json

@@ -0,0 +1,21 @@
+{
+  "title": "Methods annotated with \"@CacheResult\" should not return void",
+  "type": "CODE_SMELL",
+  "status": "ready",
+  "remediation": {
+    "func": "Constant/Issue",
+    "constantCost": "5min"
+  },
+  "tags": [],
+  "defaultSeverity": "Minor",
+  "ruleSpecification": "RSPEC-8908",
+  "sqKey": "S8908",
+  "scope": "All",
+  "quickfix": "unknown",
+  "code": {
+    "impacts": {
+      "MAINTAINABILITY": "LOW"
+    },
+    "attribute": "CLEAR"
+  }
+}