SONARJAVA-4415 S1068 ignores private fields on irrelevant annotations (#4637)

Author: kaufco

its/autoscan/src/test/resources/autoscan/diffs/diff_S6813.json

@@ -1,6 +1,6 @@
 {
   "ruleKey": "S6813",
   "hasTruePositives": true,
-  "falseNegatives": 55,
+  "falseNegatives": 57,
   "falsePositives": 0
 }

java-checks-test-sources/default/src/main/java/checks/unused/UnusedPrivateFieldCheckWithIgnoredAnnotation.java

@@ -0,0 +1,21 @@
+package checks.unused;
+
+import javax.inject.Inject;
+import javax.annotation.Nullable;
+import javax.annotation.CheckForNull;
+
+class UnusedPrivateFieldCheckWithIgnoredAnnotation {
+
+  @Inject
+  private int unusedFieldAnnotationIsIgnored; // Noncompliant [[sc=15;ec=45]] {{Remove this unused "unusedFieldAnnotationIsIgnored" private field.}}
+
+  @Nullable
+  private Object unusedFieldAnnotationIsAlsoIgnored; // Noncompliant [[sc=18;ec=52]] {{Remove this unused "unusedFieldAnnotationIsAlsoIgnored" private field.}}
+
+  @CheckForNull
+  private Object unusedFieldAnnotationIsNotIgnored; // Compliant
+
+  @Inject
+  @CheckForNull
+  private Object unusedFieldOneAnnotationIsNotIgnored; // Compliant
+}

java-checks/src/main/java/org/sonar/java/checks/unused/UnusedPrivateFieldCheck.java

@@ -28,7 +28,10 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import org.sonar.check.Rule;
+import org.sonar.check.RuleProperty;
 import org.sonar.java.checks.helpers.QuickFixHelper;
 import org.sonar.java.model.ExpressionUtils;
 import org.sonar.java.model.ModifiersUtils;
@@ -58,6 +61,9 @@
 @Rule(key = "S1068")
 public class UnusedPrivateFieldCheck extends IssuableSubscriptionVisitor {
 
+  private static final String DEFAULT_IGNORE_ANNOTATIONS_KEY = "ignoreAnnotations";
+  private static final String DEFAULT_IGNORE_ANNOTATIONS_DESCRIPTION = "Ignore annotations with next names (fully qualified class names separated with \",\").";
+
   private static final Tree.Kind[] ASSIGNMENT_KINDS = {
     Tree.Kind.ASSIGNMENT,
     Tree.Kind.MULTIPLY_ASSIGNMENT,
@@ -77,6 +83,12 @@ public class UnusedPrivateFieldCheck extends IssuableSubscriptionVisitor {
   private final Set<String> unknownIdentifiers = new HashSet<>();
   private boolean hasNativeMethod = false;
 
+  @RuleProperty(
+    key = DEFAULT_IGNORE_ANNOTATIONS_KEY,
+    description = DEFAULT_IGNORE_ANNOTATIONS_DESCRIPTION)
+  public String ignoreAnnotations = "";
+  private Set<String> ignoredAnnotations;
+
   @Override
   public List<Tree.Kind> nodesToVisit() {
     return Arrays.asList(Tree.Kind.CLASS, Tree.Kind.METHOD, Tree.Kind.EXPRESSION_STATEMENT, Tree.Kind.IDENTIFIER);
@@ -157,7 +169,7 @@ private void checkClassFields(ClassTree classTree) {
   }
 
   public void checkIfUnused(VariableTree tree) {
-    if (hasNoAnnotation(tree)) {
+    if (hasOnlyIgnoredAnnotations(tree)) {
       Symbol symbol = tree.symbol();
       String name = symbol.name();
       if (symbol.isPrivate()
@@ -178,8 +190,19 @@ private boolean onlyUsedInVariableAssignment(Symbol symbol) {
     return symbol.usages().size() == assignments.getOrDefault(symbol, Collections.emptyList()).size();
   }
 
-  private static boolean hasNoAnnotation(VariableTree tree) {
-    return tree.modifiers().annotations().isEmpty();
+  private boolean hasOnlyIgnoredAnnotations(VariableTree tree) {
+    return tree.modifiers().annotations().stream().allMatch(
+      it -> getIgnoredAnnotations().contains(it.annotationType().symbolType().fullyQualifiedName()));
+  }
+
+  private Set<String> getIgnoredAnnotations() {
+    if (ignoredAnnotations == null) {
+      ignoredAnnotations = Stream.of(ignoreAnnotations.split(","))
+        .map(String::trim)
+        .filter(it -> !it.isEmpty())
+        .collect(Collectors.toSet());
+    }
+    return ignoredAnnotations;
   }
 
   private void collectAssignment(ExpressionTree expressionTree) {

java-checks/src/test/java/org/sonar/java/checks/unused/UnusedPrivateFieldCheckTest.java

@@ -61,4 +61,14 @@ void test_quick_fixes() {
       .withQuickFixes()
       .verifyIssues();
   }
+
+  @Test
+  void test_ignored_annotation() {
+    UnusedPrivateFieldCheck check = new UnusedPrivateFieldCheck();
+    check.ignoreAnnotations = "javax.inject.Inject,,javax.annotation.Nullable";
+    CheckVerifier.newVerifier()
+      .onFile(mainCodeSourcesPath("checks/unused/UnusedPrivateFieldCheckWithIgnoredAnnotation.java"))
+      .withCheck(check)
+      .verifyIssues();
+  }
 }

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

@@ -32,7 +32,8 @@ <h3>Exceptions</h3>
 <ul>
   <li> Annotated fields and classes annotated with Lombok annotations </li>
 </ul>
-<p>The unused field in this class will not be reported by the rule as it is annotated.</p>
+<p>The unused field in this class will not be reported by the rule as it is annotated, except if annotation class <code>SomeAnnotation</code> is
+listed in the <code>ignoreAnnotations</code> parameter (see Parameters).</p>
 <pre>
 public class MyClass {
   @SomeAnnotation