Introduce SonarCloud integration and resolve assorted violations (#575)

.github/workflows/build.yaml

@@ -54,4 +54,3 @@ jobs:
         run: mvn build-helper:remove-project-artifact
 
 # XXX: Enable Codecov once we "go public".
-# XXX: Enable SonarCloud once we "go public".

.github/workflows/sonarcloud.yml

@@ -0,0 +1,36 @@
+# Analyzes the code base using SonarCloud. See
+# https://sonarcloud.io/project/overview?id=PicnicSupermarket_error-prone-support.
+name: SonarCloud analysis
+on:
+  pull_request:
+  push:
+    branches: [ master ]
+  schedule:
+    - cron: '0 4 * * 1'
+permissions:
+  contents: read
+jobs:
+  analyze:
+    permissions:
+      contents: read
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3.1.0
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Set up JDK
+        uses: actions/setup-java@v3.8.0
+        with:
+          java-version: 17.0.6
+          distribution: temurin
+          cache: maven
+      - name: Create missing `test` directory
+        # XXX: Drop this step in favour of actually having a test.
+        run: mkdir refaster-compiler/src/test
+      - name: Perform SonarCloud analysis
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        run: mvn -T1C jacoco:prepare-agent verify jacoco:report sonar:sonar -Dverification.skip -Dsonar.projectKey=PicnicSupermarket_error-prone-support

documentation-support/src/main/java/tech/picnic/errorprone/documentation/ExtractorType.java

@@ -25,6 +25,7 @@ enum ExtractorType {
     return identifier;
   }
 
+  @SuppressWarnings("java:S1452" /* The extractor returns data of an unspecified type. */)
   Extractor<?> getExtractor() {
     return extractor;
   }

documentation-support/src/test/java/tech/picnic/errorprone/documentation/DocumentationGeneratorTaskListenerTest.java

@@ -67,10 +67,11 @@ final class DocumentationGeneratorTaskListenerTest {
 
   @Test
   void excessArguments(@TempDir Path outputDirectory) {
+    String actualOutputDirectory = outputDirectory.toAbsolutePath() + " extra-arg";
     assertThatThrownBy(
             () ->
                 Compilation.compileWithDocumentationGenerator(
-                    outputDirectory.toAbsolutePath() + " extra-arg", "A.java", "package pkg;"))
+                    actualOutputDirectory, "A.java", "package pkg;"))
         .isInstanceOf(IllegalArgumentException.class)
         .hasMessage("Precisely one path must be provided");
   }

error-prone-contrib/README.md

@@ -24,7 +24,6 @@ project:
 
 - Document how to apply patches.
 - Document each of the checks.
-- Add [SonarQube][sonarcloud] and [Codecov][codecov] integrations.
 - Add non-Java file formatting support, like we have internally at Picnic.
   (I.e., somehow open-source that stuff.)
 - Auto-generate a website listing each of the checks, just like the Error Prone
@@ -273,7 +272,6 @@ Refaster's expressiveness:
 [autorefactor]: https://autorefactor.org
 [bettercodehub]: https://bettercodehub.com
 [checkstyle-external-project-tests]: https://github.com/checkstyle/checkstyle/blob/master/wercker.yml
-[codecov]: https://codecov.io
 [error-prone-bug-patterns]: https://errorprone.info/bugpatterns
 [error-prone]: https://errorprone.info
 [error-prone-repo]: https://github.com/google/error-prone
@@ -283,4 +281,3 @@ Refaster's expressiveness:
 [main-contributing]: ../CONTRIBUTING.md
 [main-readme]: ../README.md
 [modernizer-maven-plugin]: https://github.com/gaul/modernizer-maven-plugin
-[sonarcloud]: https://sonarcloud.io

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AssociativeMethodInvocation.java

@@ -39,7 +39,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "These methods implement an associative operation, so the list of operands can be flattened",
+        "This method implements an associative operation, so the list of operands can be flattened",
     link = BUG_PATTERNS_BASE_URL + "AssociativeMethodInvocation",
     linkType = CUSTOM,
     severity = SUGGESTION,
@@ -70,24 +70,31 @@ public final class AssociativeMethodInvocation extends BugChecker
 
     for (Matcher<ExpressionTree> matcher : ASSOCIATIVE_OPERATIONS) {
       if (matcher.matches(tree, state)) {
-        SuggestedFix.Builder fix = SuggestedFix.builder();
+        SuggestedFix fix = processMatchingArguments(tree, matcher, state);
-        for (ExpressionTree arg : tree.getArguments()) {
+        return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix);
-          if (matcher.matches(arg, state)) {
-            MethodInvocationTree invocation = (MethodInvocationTree) arg;
-            fix.merge(
-                invocation.getArguments().isEmpty()
-                    ? SuggestedFixes.removeElement(arg, tree.getArguments(), state)
-                    : SourceCode.unwrapMethodInvocation(invocation, state));
-          }
-        }
-
-        return fix.isEmpty() ? Description.NO_MATCH : describeMatch(tree, fix.build());
       }
     }
 
     return Description.NO_MATCH;
   }
 
+  private static SuggestedFix processMatchingArguments(
+      MethodInvocationTree tree, Matcher<ExpressionTree> matcher, VisitorState state) {
+    SuggestedFix.Builder fix = SuggestedFix.builder();
+
+    for (ExpressionTree arg : tree.getArguments()) {
+      if (matcher.matches(arg, state)) {
+        MethodInvocationTree invocation = (MethodInvocationTree) arg;
+        fix.merge(
+            invocation.getArguments().isEmpty()
+                ? SuggestedFixes.removeElement(invocation, tree.getArguments(), state)
+                : SourceCode.unwrapMethodInvocation(invocation, state));
+      }
+    }
+
+    return fix.build();
+  }
+
   private static Matcher<MethodInvocationTree> hasArgumentOfType(Supplier<Type> type) {
     return (tree, state) ->
         tree.getArguments().stream()

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/AutowiredConstructor.java

@@ -58,8 +58,8 @@ public final class AutowiredConstructor extends BugChecker implements ClassTreeM
 
     /*
      * This is the only `@Autowired` constructor: suggest that it be removed. Note that this likely
-     * means that the associated import can be removed as well. Rather than adding code for this case we
+     * means that the associated import can be removed as well. Rather than adding code for this
-     * leave flagging the unused import to Error Prone's `RemoveUnusedImports` check.
+     * case we leave flagging the unused import to Error Prone's `RemoveUnusedImports` check.
      */
     AnnotationTree annotation = Iterables.getOnlyElement(annotations);
     return describeMatch(annotation, SourceCode.deleteWithTrailingWhitespace(annotation, state));

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/CollectorMutability.java

@@ -30,7 +30,7 @@ import tech.picnic.errorprone.bugpatterns.util.ThirdPartyLibrary;
 @AutoService(BugChecker.class)
 @BugPattern(
     summary =
-        "Avoid `Collectors.to{List,Map,Set}` in favour of alternatives that emphasize (im)mutability",
+        "Avoid `Collectors.to{List,Map,Set}` in favor of collectors that emphasize (im)mutability",
     link = BUG_PATTERNS_BASE_URL + "CollectorMutability",
     linkType = CUSTOM,
     severity = WARNING,

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/EmptyMethod.java

@@ -42,6 +42,7 @@ public final class EmptyMethod extends BugChecker implements MethodTreeMatcher {
   public EmptyMethod() {}
 
   @Override
+  @SuppressWarnings("java:S1067" /* Chaining disjunctions like this does not impact readability. */)
   public Description matchMethod(MethodTree tree, VisitorState state) {
     if (tree.getBody() == null
         || !tree.getBody().getStatements().isEmpty()

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/ErrorProneTestHelperSourceFormat.java

@@ -104,7 +104,9 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
     String formatted;
     try {
       formatted = formatSourceCode(source, retainUnusedImports).trim();
-    } catch (FormatterException e) {
+    } catch (
+        @SuppressWarnings("java:S1166" /* Stack trace not relevant. */)
+        FormatterException e) {
       return buildDescription(methodInvocation)
           .setMessage(String.format("Source code is malformed: %s", e.getMessage()))
           .build();
@@ -131,7 +133,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
         SuggestedFix.replace(
             startPos,
             endPos,
-            Splitter.on('\n')
+            Splitter.on(System.lineSeparator())
                 .splitToStream(formatted)
                 .map(state::getConstantExpression)
                 .collect(joining(", "))));
@@ -157,7 +159,7 @@ public final class ErrorProneTestHelperSourceFormat extends BugChecker
         return Optional.empty();
       }
 
-      source.append(value).append('\n');
+      source.append(value).append(System.lineSeparator());
     }
 
     return Optional.of(source.toString());

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationAttributeListing.java

@@ -58,6 +58,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     linkType = CUSTOM,
     severity = SUGGESTION,
     tags = STYLE)
+@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
 public final class LexicographicalAnnotationAttributeListing extends BugChecker
     implements AnnotationTreeMatcher {
   private static final long serialVersionUID = 1L;

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/LexicographicalAnnotationListing.java

@@ -46,9 +46,19 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 public final class LexicographicalAnnotationListing extends BugChecker
     implements MethodTreeMatcher {
   private static final long serialVersionUID = 1L;
+  /**
+   * A comparator that minimally reorders {@link AnnotationType}s, such that declaration annotations
+   * are placed before type annotations.
+   */
+  @SuppressWarnings({
+    "java:S1067",
+    "java:S3358"
+  } /* Avoiding the nested ternary operator hurts readability. */)
   private static final Comparator<@Nullable AnnotationType> BY_ANNOTATION_TYPE =
       (a, b) ->
-          (a == null || a == DECLARATION) && b == TYPE ? -1 : a == TYPE && b == DECLARATION ? 1 : 0;
+          (a == null || a == DECLARATION) && b == TYPE
+              ? -1
+              : (a == TYPE && b == DECLARATION ? 1 : 0);
 
   /** Instantiates a new {@link LexicographicalAnnotationListing} instance. */
   public LexicographicalAnnotationListing() {}

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/MethodReferenceUsage.java

@@ -118,6 +118,8 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
         .flatMap(expectedInstance -> constructMethodRef(lambdaExpr, subTree, expectedInstance));
   }
 
+  @SuppressWarnings(
+      "java:S1151" /* Extracting `IDENTIFIER` case block to separate method does not improve readability. */)
   private static Optional<SuggestedFix.Builder> constructMethodRef(
       LambdaExpressionTree lambdaExpr,
       MethodInvocationTree subTree,
@@ -130,10 +132,9 @@ public final class MethodReferenceUsage extends BugChecker implements LambdaExpr
           return Optional.empty();
         }
         Symbol sym = ASTHelpers.getSymbol(methodSelect);
-        if (!ASTHelpers.isStatic(sym)) {
+        return ASTHelpers.isStatic(sym)
-          return constructFix(lambdaExpr, "this", methodSelect);
+            ? constructFix(lambdaExpr, sym.owner, methodSelect)
-        }
+            : constructFix(lambdaExpr, "this", methodSelect);
-        return constructFix(lambdaExpr, sym.owner, methodSelect);
       case MEMBER_SELECT:
         return constructMethodRef(lambdaExpr, (MemberSelectTree) methodSelect, expectedInstance);
       default:

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/NonEmptyMono.java

@@ -43,6 +43,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 // emitting a value (e.g. `Mono.empty()`, `someFlux.then()`, ...), or known not to complete normally
 // (`Mono.never()`, `someFlux.repeat()`, `Mono.error(...)`, ...). The latter category could
 // potentially be split out further.
+@SuppressWarnings("java:S1192" /* Factoring out repeated method names impacts readability. */)
 public final class NonEmptyMono extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> MONO_SIZE_CHECK =

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/PrimitiveComparison.java

@@ -49,6 +49,7 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     linkType = CUSTOM,
     severity = WARNING,
     tags = PERFORMANCE)
+@SuppressWarnings("java:S1192" /* Factoring out repeated method names impacts readability. */)
 public final class PrimitiveComparison extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Matcher<ExpressionTree> STATIC_COMPARISON_METHOD =

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RedundantStringConversion.java

@@ -62,6 +62,11 @@ import tech.picnic.errorprone.bugpatterns.util.SourceCode;
     linkType = CUSTOM,
     severity = SUGGESTION,
     tags = SIMPLIFICATION)
+@SuppressWarnings({
+  "java:S1192" /* Factoring out repeated method names impacts readability. */,
+  "java:S2160" /* Super class equality definition suffices. */,
+  "key-to-resolve-AnnotationUseStyle-and-TrailingComment-check-conflict"
+})
 public final class RedundantStringConversion extends BugChecker
     implements BinaryTreeMatcher, CompoundAssignmentTreeMatcher, MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
@@ -163,7 +168,7 @@ public final class RedundantStringConversion extends BugChecker
     ExpressionTree lhs = tree.getLeftOperand();
     ExpressionTree rhs = tree.getRightOperand();
     if (!STRING.matches(lhs, state)) {
-      return finalize(tree, tryFix(rhs, state, STRING));
+      return createDescription(tree, tryFix(rhs, state, STRING));
     }
 
     List<SuggestedFix.Builder> fixes = new ArrayList<>();
@@ -177,7 +182,7 @@ public final class RedundantStringConversion extends BugChecker
     }
     tryFix(rhs, state, ANY_EXPR).ifPresent(fixes::add);
 
-    return finalize(tree, fixes.stream().reduce(SuggestedFix.Builder::merge));
+    return createDescription(tree, fixes.stream().reduce(SuggestedFix.Builder::merge));
   }
 
   @Override
@@ -186,36 +191,36 @@ public final class RedundantStringConversion extends BugChecker
       return Description.NO_MATCH;
     }
 
-    return finalize(tree, tryFix(tree.getExpression(), state, ANY_EXPR));
+    return createDescription(tree, tryFix(tree.getExpression(), state, ANY_EXPR));
   }
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
     if (STRINGBUILDER_APPEND_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 0));
+      return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 0));
     }
 
     if (STRINGBUILDER_INSERT_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixPositionalConverter(tree.getArguments(), state, 1));
+      return createDescription(tree, tryFixPositionalConverter(tree.getArguments(), state, 1));
     }
 
     if (FORMATTER_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixFormatter(tree.getArguments(), state));
+      return createDescription(tree, tryFixFormatter(tree.getArguments(), state));
     }
 
     if (GUAVA_GUARD_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixGuavaGuard(tree.getArguments(), state));
+      return createDescription(tree, tryFixGuavaGuard(tree.getArguments(), state));
     }
 
     if (SLF4J_LOGGER_INVOCATION.matches(tree, state)) {
-      return finalize(tree, tryFixSlf4jLogger(tree.getArguments(), state));
+      return createDescription(tree, tryFixSlf4jLogger(tree.getArguments(), state));
     }
 
     if (instanceMethod().matches(tree, state)) {
-      return finalize(tree, tryFix(tree, state, STRING));
+      return createDescription(tree, tryFix(tree, state, STRING));
     }
 
-    return finalize(tree, tryFix(tree, state, NON_NULL_STRING));
+    return createDescription(tree, tryFix(tree, state, NON_NULL_STRING));
   }
 
   private Optional<SuggestedFix.Builder> tryFixPositionalConverter(
@@ -298,7 +303,7 @@ public final class RedundantStringConversion extends BugChecker
 
     /* Simplify the values to be plugged into the format pattern, if possible. */
     return arguments.stream()
-        .skip(patternIndex + 1)
+        .skip(patternIndex + 1L)
         .map(arg -> tryFix(arg, state, remainingArgFilter))
         .flatMap(Optional::stream)
         .reduce(SuggestedFix.Builder::merge);
@@ -362,7 +367,7 @@ public final class RedundantStringConversion extends BugChecker
     return Optional.of(Iterables.getOnlyElement(methodInvocation.getArguments()));
   }
 
-  private Description finalize(Tree tree, Optional<SuggestedFix.Builder> fixes) {
+  private Description createDescription(Tree tree, Optional<SuggestedFix.Builder> fixes) {
     return fixes
         .map(SuggestedFix.Builder::build)
         .map(fix -> describeMatch(tree, fix))

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestMappingAnnotation.java

@@ -99,8 +99,9 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
             && LACKS_PARAMETER_ANNOTATION.matches(tree, state)
         ? buildDescription(tree)
             .setMessage(
-                "Not all parameters of this request mapping method are annotated; this may be a mistake. "
+                "Not all parameters of this request mapping method are annotated; this may be a "
-                    + "If the unannotated parameters represent query string parameters, annotate them with `@RequestParam`.")
+                    + "mistake. If the unannotated parameters represent query string parameters, "
+                    + "annotate them with `@RequestParam`.")
             .build()
         : Description.NO_MATCH;
   }

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/RequestParamType.java

@@ -38,6 +38,7 @@ import tech.picnic.errorprone.bugpatterns.util.Flags;
     linkType = CUSTOM,
     severity = ERROR,
     tags = LIKELY_ERROR)
+@SuppressWarnings("java:S2160" /* Super class equality definition suffices. */)
 public final class RequestParamType extends BugChecker implements VariableTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String SUPPORTED_CUSTOM_TYPES_FLAG = "RequestParamType:SupportedCustomTypes";

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/AnnotationAttributeMatcher.java

@@ -103,7 +103,7 @@ public final class AnnotationAttributeMatcher implements Serializable {
    * @param tree The annotation AST node to be inspected.
    * @return Any matching annotation arguments.
    */
-  public Stream<? extends ExpressionTree> extractMatchingArguments(AnnotationTree tree) {
+  public Stream<ExpressionTree> extractMatchingArguments(AnnotationTree tree) {
     Type type = ASTHelpers.getType(tree.getAnnotationType());
     if (type == null) {
       return Stream.empty();
@@ -111,6 +111,7 @@ public final class AnnotationAttributeMatcher implements Serializable {
 
     String annotationType = type.toString();
     return tree.getArguments().stream()
+        .map(ExpressionTree.class::cast)
         .filter(a -> matches(annotationType, extractAttributeName(a)));
   }
 

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/JavaKeywords.java

@@ -114,6 +114,7 @@ public final class JavaKeywords {
    * @see <a href="https://docs.oracle.com/javase/specs/jls/se17/html/jls-3.html#jls-3.8">JDK 17 JLS
    *     section 3.8: Identifiers</a>
    */
+  @SuppressWarnings("java:S1067" /* Chaining conjunctions like this does not impact readability. */)
   public static boolean isValidIdentifier(String str) {
     return !str.isEmpty()
         && !isReservedKeyword(str)

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactory.java

@@ -18,6 +18,9 @@ import java.util.regex.Pattern;
 public final class MethodMatcherFactory {
   private static final Splitter ARGUMENT_TYPE_SPLITTER =
       Splitter.on(',').trimResults().omitEmptyStrings();
+  // XXX: Check whether we can use a parser for "standard" Java signatures here. Maybe
+  // `sun.reflect.generics.parser.SignatureParser`?
+  @SuppressWarnings("java:S5998" /* In practice there will be only modest recursion. */)
   private static final Pattern METHOD_SIGNATURE =
       Pattern.compile("([^\\s#(,)]+)#([^\\s#(,)]+)\\(((?:[^\\s#(,)]+(?:,[^\\s#(,)]+)*)?)\\)");
 

error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/util/ThirdPartyLibrary.java

@@ -90,7 +90,9 @@ public enum ThirdPartyLibrary {
     try {
       classFinder.loadClass(state.getSymtab().unnamedModule, binaryName);
       return true;
-    } catch (CompletionFailure e) {
+    } catch (
+        @SuppressWarnings("java:S1166" /* Not exceptional. */)
+        CompletionFailure e) {
       return false;
     }
   }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJPrimitiveRules.java

@@ -23,6 +23,8 @@ final class AssertJPrimitiveRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */)
     AbstractBooleanAssert<?> before(double actual, double expected) {
       return Refaster.anyOf(
           assertThat(actual == expected).isTrue(), assertThat(actual != expected).isFalse());
@@ -43,6 +45,8 @@ final class AssertJPrimitiveRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The (in)equality checks are fragile, but may be seen in the wild. */)
     AbstractBooleanAssert<?> before(double actual, double expected) {
       return Refaster.anyOf(
           assertThat(actual != expected).isTrue(), assertThat(actual == expected).isFalse());

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJRules.java

@@ -2024,8 +2024,8 @@ final class AssertJRules {
   ////////////////////////////////////////////////////////////////////////////
   // Above: Generated code.
 
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////
   // Organize the code below.
 
   // XXX: Do the "single Comparable" match shown below.

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRules.java

@@ -47,7 +47,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessage {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalArgumentException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -64,7 +64,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatIllegalArgumentException()
@@ -85,7 +85,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageStartingWith {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalArgumentException()
           .isThrownBy(throwingCallable)
@@ -104,7 +104,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageContaining {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalArgumentException()
           .isThrownBy(throwingCallable)
@@ -123,7 +123,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalArgumentException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalArgumentException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, @Repeated CharSequence values) {
       return assertThatIllegalArgumentException()
@@ -157,7 +157,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessage {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -174,7 +174,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatIllegalStateException()
@@ -195,7 +195,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageStartingWith {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException()
           .isThrownBy(throwingCallable)
@@ -214,7 +214,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageContaining {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException()
           .isThrownBy(throwingCallable)
@@ -233,7 +233,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByIllegalStateExceptionHasMessageNotContaining {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByIllegalStateException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByIllegalStateException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIllegalStateException()
           .isThrownBy(throwingCallable)
@@ -265,7 +265,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByNullPointerExceptionHasMessage {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatNullPointerException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -282,7 +282,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByNullPointerExceptionHasMessageParameters {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatNullPointerException()
@@ -303,7 +303,7 @@ final class AssertJThrowingCallableRules {
   static final class AssertThatThrownByNullPointerExceptionHasMessageStartingWith {
     @BeforeTemplate
     @SuppressWarnings(
-        "AssertThatThrownByNullPointerException" /* Matches strictly more specific expressions. */)
+        "AssertThatThrownByNullPointerException" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatNullPointerException()
           .isThrownBy(throwingCallable)
@@ -334,8 +334,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByIOExceptionHasMessage {
     @BeforeTemplate
-    @SuppressWarnings(
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
-        "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIOException().isThrownBy(throwingCallable).withMessage(message);
     }
@@ -351,8 +350,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByIOExceptionHasMessageParameters {
     @BeforeTemplate
-    @SuppressWarnings(
+    @SuppressWarnings("AssertThatThrownByIOException" /* This is a more specific template. */)
-        "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
     AbstractObjectAssert<?, ?> before(
         ThrowingCallable throwingCallable, String message, @Repeated Object parameters) {
       return assertThatIOException().isThrownBy(throwingCallable).withMessage(message, parameters);
@@ -385,7 +383,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessage {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         Class<? extends Throwable> exceptionType,
         ThrowingCallable throwingCallable,
@@ -407,7 +405,7 @@ final class AssertJThrowingCallableRules {
 
   static final class AssertThatThrownByHasMessageParameters {
     @BeforeTemplate
-    @SuppressWarnings("AssertThatThrownBy" /* Matches strictly more specific expressions. */)
+    @SuppressWarnings("AssertThatThrownBy" /* This is a more specific template. */)
     AbstractObjectAssert<?, ?> before(
         Class<? extends Throwable> exceptionType,
         ThrowingCallable throwingCallable,

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssortedRules.java

@@ -115,6 +115,7 @@ final class AssortedRules {
   // intelligently.
   static final class LogicalImplication {
     @BeforeTemplate
+    @SuppressWarnings("java:S2589" /* This violation will be rewritten. */)
     boolean before(boolean firstTest, boolean secondTest) {
       return firstTest || (!firstTest && secondTest);
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/BigDecimalRules.java

@@ -56,6 +56,7 @@ final class BigDecimalRules {
   // `BugChecker`.
   static final class BigDecimalValueOf {
     @BeforeTemplate
+    @SuppressWarnings("java:S2111" /* This violation will be rewritten. */)
     BigDecimal before(double value) {
       return new BigDecimal(value);
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/CollectionRules.java

@@ -35,6 +35,7 @@ final class CollectionRules {
    */
   static final class CollectionIsEmpty<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1155" /* This violation will be rewritten. */)
     boolean before(Collection<T> collection) {
       return Refaster.anyOf(
           collection.size() == 0,

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ComparatorRules.java

@@ -233,6 +233,7 @@ final class ComparatorRules {
   /** Prefer {@link Comparators#min(Comparable, Comparable)}} over more verbose alternatives. */
   static final class MinOfPairNaturalOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2) {
       return Refaster.anyOf(
           value1.compareTo(value2) <= 0 ? value1 : value2,
@@ -259,6 +260,7 @@ final class ComparatorRules {
    */
   static final class MinOfPairCustomOrder<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2, Comparator<T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) <= 0 ? value1 : value2,
@@ -299,6 +301,7 @@ final class ComparatorRules {
   /** Prefer {@link Comparators#max(Comparable, Comparable)}} over more verbose alternatives. */
   static final class MaxOfPairNaturalOrder<T extends Comparable<? super T>> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2) {
       return Refaster.anyOf(
           value1.compareTo(value2) >= 0 ? value1 : value2,
@@ -325,6 +328,7 @@ final class ComparatorRules {
    */
   static final class MaxOfPairCustomOrder<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1067" /* The conditional operators are independent. */)
     T before(T value1, T value2, Comparator<T> cmp) {
       return Refaster.anyOf(
           cmp.compare(value1, value2) >= 0 ? value1 : value2,

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/DoubleStreamRules.java

@@ -237,6 +237,7 @@ final class DoubleStreamRules {
   /** Prefer {@link DoubleStream#anyMatch(DoublePredicate)} over more contrived alternatives. */
   static final class DoubleStreamAnyMatch {
     @BeforeTemplate
+    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
     boolean before(DoubleStream stream, DoublePredicate predicate) {
       return Refaster.anyOf(
           !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent());

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/EqualityRules.java

@@ -30,6 +30,7 @@ final class EqualityRules {
 
     @AfterTemplate
     @AlsoNegation
+    @SuppressWarnings("java:S1698" /* Reference comparison is valid for enums. */)
     boolean after(T a, T b) {
       return a == b;
     }
@@ -56,6 +57,7 @@ final class EqualityRules {
   /** Avoid double negations; this is not Javascript. */
   static final class DoubleNegation {
     @BeforeTemplate
+    @SuppressWarnings("java:S2761" /* This violation will be rewritten. */)
     boolean before(boolean b) {
       return !!b;
     }
@@ -72,6 +74,7 @@ final class EqualityRules {
    */
   // XXX: Replacing `a ? !b : b` with `a != b` changes semantics if both `a` and `b` are boxed
   // booleans.
+  @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
   static final class Negation {
     @BeforeTemplate
     boolean before(boolean a, boolean b) {
@@ -79,6 +82,8 @@ final class EqualityRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The equality check is fragile, but may be seen in the wild. */)
     boolean before(double a, double b) {
       return !(a == b);
     }
@@ -100,6 +105,7 @@ final class EqualityRules {
    */
   // XXX: Replacing `a ? b : !b` with `a == b` changes semantics if both `a` and `b` are boxed
   // booleans.
+  @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
   static final class IndirectDoubleNegation {
     @BeforeTemplate
     boolean before(boolean a, boolean b) {
@@ -107,6 +113,8 @@ final class EqualityRules {
     }
 
     @BeforeTemplate
+    @SuppressWarnings(
+        "java:S1244" /* The inequality check is fragile, but may be seen in the wild. */)
     boolean before(double a, double b) {
       return !(a != b);
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ImmutableMapRules.java

@@ -250,7 +250,8 @@ final class ImmutableMapRules {
    * Prefer {@link ImmutableMap#of(Object, Object, Object, Object)} over alternatives that don't
    * communicate the immutability of the resulting map at the type level.
    */
-  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will
+  // also make it easier to rewrite various `ImmutableMap.builder()` variants.
   static final class ImmutableMapOf2<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2) {
@@ -267,7 +268,8 @@ final class ImmutableMapRules {
    * Prefer {@link ImmutableMap#of(Object, Object, Object, Object, Object, Object)} over
    * alternatives that don't communicate the immutability of the resulting map at the type level.
    */
-  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will
+  // also make it easier to rewrite various `ImmutableMap.builder()` variants.
   static final class ImmutableMapOf3<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3) {
@@ -285,7 +287,9 @@ final class ImmutableMapRules {
    * over alternatives that don't communicate the immutability of the resulting map at the type
    * level.
    */
-  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will
+  // also make it easier to rewrite various `ImmutableMap.builder()` variants.
+  @SuppressWarnings("java:S107" /* Can't avoid many method parameters here. */)
   static final class ImmutableMapOf4<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
@@ -303,7 +307,9 @@ final class ImmutableMapRules {
    * Object, Object)} over alternatives that don't communicate the immutability of the resulting map
    * at the type level.
    */
-  // XXX: Also rewrite the `ImmutableMap.builder()` variant?
+  // XXX: Consider introducing a `BugChecker` to replace these `ImmutableMapOfX` rules. That will
+  // also make it easier to rewrite various `ImmutableMap.builder()` variants.
+  @SuppressWarnings("java:S107" /* Can't avoid many method parameters here. */)
   static final class ImmutableMapOf5<K, V> {
     @BeforeTemplate
     Map<K, V> before(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/IntStreamRules.java

@@ -250,6 +250,7 @@ final class IntStreamRules {
   /** Prefer {@link IntStream#anyMatch(IntPredicate)} over more contrived alternatives. */
   static final class IntStreamAnyMatch {
     @BeforeTemplate
+    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
     boolean before(IntStream stream, IntPredicate predicate) {
       return Refaster.anyOf(
           !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent());

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/JUnitToAssertJRules.java

@@ -34,8 +34,7 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
  * <p>Note that, while both libraries throw an {@link AssertionError} in case of an assertion
  * failure, the exact subtype used generally differs.
  */
-// XXX: Not all `org.assertj.core.api.Assertions` methods have an associated Refaster rule yet;
+// XXX: Not all JUnit `Assertions` methods have an associated Refaster rule yet; expand this class.
-// expand this class.
 // XXX: Introduce a `@Matcher` on `Executable` and `ThrowingSupplier` expressions, such that they
 // are only matched if they are also compatible with the `ThrowingCallable` functional interface.
 // When implementing such a matcher, note that expressions with a non-void return type such as
@@ -45,7 +44,7 @@ import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 final class JUnitToAssertJRules {
   private JUnitToAssertJRules() {}
 
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Assertions.class,
         assertDoesNotThrow(() -> null),

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/LongStreamRules.java

@@ -250,6 +250,7 @@ final class LongStreamRules {
   /** Prefer {@link LongStream#anyMatch(LongPredicate)} over more contrived alternatives. */
   static final class LongStreamAnyMatch {
     @BeforeTemplate
+    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
     boolean before(LongStream stream, LongPredicate predicate) {
       return Refaster.anyOf(
           !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent());

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java

@@ -68,7 +68,10 @@ final class OptionalRules {
   /** Prefer {@link Optional#orElseThrow()} over the less explicit {@link Optional#get()}. */
   static final class OptionalOrElseThrow<T> {
     @BeforeTemplate
-    @SuppressWarnings("NullAway")
+    @SuppressWarnings({
+      "java:S3655" /* Matched expressions are in practice embedded in a larger context. */,
+      "NullAway"
+    })
     T before(Optional<T> optional) {
       return optional.get();
     }
@@ -304,14 +307,12 @@ final class OptionalRules {
     abstract Optional<S> toOptionalFunction(@MayOptionallyUse T element);
 
     @BeforeTemplate
-    Optional<R> before(
+    Optional<R> before(Optional<T> optional, Function<? super S, Optional<? extends R>> function) {
-        Optional<T> optional, Function<? super S, ? extends Optional<? extends R>> function) {
       return optional.flatMap(v -> toOptionalFunction(v).flatMap(function));
     }
 
     @AfterTemplate
-    Optional<R> after(
+    Optional<R> after(Optional<T> optional, Function<? super S, Optional<? extends R>> function) {
-        Optional<T> optional, Function<? super S, ? extends Optional<? extends R>> function) {
       return optional.flatMap(v -> toOptionalFunction(v)).flatMap(function);
     }
   }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PreconditionsRules.java

@@ -91,6 +91,7 @@ final class PreconditionsRules {
   /** Prefer {@link Objects#requireNonNull(Object)} over more verbose alternatives. */
   static final class RequireNonNullStatement<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1695" /* This violation will be rewritten. */)
     void before(T object) {
       if (object == null) {
         throw new NullPointerException();
@@ -121,6 +122,7 @@ final class PreconditionsRules {
   /** Prefer {@link Objects#requireNonNull(Object, String)} over more verbose alternatives. */
   static final class RequireNonNullWithMessageStatement<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S1695" /* This violation will be rewritten. */)
     void before(T object, String message) {
       if (object == null) {
         throw new NullPointerException(message);

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/PrimitiveRules.java

@@ -13,6 +13,7 @@ final class PrimitiveRules {
   /** Avoid contrived ways of expressing the "less than" relationship. */
   static final class LessThan {
     @BeforeTemplate
+    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
     boolean before(double a, double b) {
       return !(a >= b);
     }
@@ -26,6 +27,7 @@ final class PrimitiveRules {
   /** Avoid contrived ways of expressing the "less than or equal to" relationship. */
   static final class LessThanOrEqualTo {
     @BeforeTemplate
+    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
     boolean before(double a, double b) {
       return !(a > b);
     }
@@ -39,6 +41,7 @@ final class PrimitiveRules {
   /** Avoid contrived ways of expressing the "greater than" relationship. */
   static final class GreaterThan {
     @BeforeTemplate
+    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
     boolean before(double a, double b) {
       return !(a <= b);
     }
@@ -52,6 +55,7 @@ final class PrimitiveRules {
   /** Avoid contrived ways of expressing the "greater than or equal to" relationship. */
   static final class GreaterThanOrEqualTo {
     @BeforeTemplate
+    @SuppressWarnings("java:S1940" /* This violation will be rewritten. */)
     boolean before(double a, double b) {
       return !(a < b);
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/ReactorRules.java

@@ -620,6 +620,7 @@ final class ReactorRules {
     abstract S transformation(@MayOptionallyUse T value);
 
     @BeforeTemplate
+    @SuppressWarnings("java:S138" /* Method is long, but not complex. */)
     Publisher<S> before(Flux<T> flux, boolean delayUntilEnd, int maxConcurrency, int prefetch) {
       return Refaster.anyOf(
           flux.concatMap(

error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/StreamRules.java

@@ -316,6 +316,7 @@ final class StreamRules {
   /** Prefer {@link Stream#noneMatch(Predicate)} over more contrived alternatives. */
   static final class StreamNoneMatch<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
     boolean before(Stream<T> stream, Predicate<? super T> predicate) {
       return Refaster.anyOf(
           !stream.anyMatch(predicate),
@@ -347,6 +348,7 @@ final class StreamRules {
   /** Prefer {@link Stream#anyMatch(Predicate)} over more contrived alternatives. */
   static final class StreamAnyMatch<T> {
     @BeforeTemplate
+    @SuppressWarnings("java:S4034" /* This violation will be rewritten. */)
     boolean before(Stream<T> stream, Predicate<? super T> predicate) {
       return Refaster.anyOf(
           !stream.noneMatch(predicate), stream.filter(predicate).findAny().isPresent());

error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/util/MethodMatcherFactoryTest.java

@@ -2,6 +2,7 @@ package tech.picnic.errorprone.bugpatterns.util;
 
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 import com.google.common.collect.ImmutableList;
 import com.google.errorprone.BugPattern;
@@ -13,7 +14,11 @@ import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MethodInvocationTree;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 final class MethodMatcherFactoryTest {
   private static final Matcher<ExpressionTree> TEST_MATCHER =
@@ -24,16 +29,20 @@ final class MethodMatcherFactoryTest {
                   "com.example.A#m2(java.lang.String)",
                   "com.example.sub.B#m3(int,int)"));
 
-  @Test
+  private static Stream<Arguments> createWithMalformedSignaturesTestCases() {
-  void createWithMalformedSignatures() {
+    /* { signatures } */
+    return Stream.of(
+        arguments(ImmutableList.of("foo.bar")),
+        arguments(ImmutableList.of("foo.bar#baz")),
+        arguments(ImmutableList.of("a", "foo.bar#baz()")),
+        arguments(ImmutableList.of("foo.bar#baz()", "a")));
+  }
+
+  @MethodSource("createWithMalformedSignaturesTestCases")
+  @ParameterizedTest
+  void createWithMalformedSignatures(ImmutableList<String> signatures) {
     MethodMatcherFactory factory = new MethodMatcherFactory();
-    assertThatThrownBy(() -> factory.create(ImmutableList.of("foo.bar")))
+    assertThatThrownBy(() -> factory.create(signatures))
-        .isInstanceOf(IllegalArgumentException.class);
-    assertThatThrownBy(() -> factory.create(ImmutableList.of("foo.bar#baz")))
-        .isInstanceOf(IllegalArgumentException.class);
-    assertThatThrownBy(() -> factory.create(ImmutableList.of("a", "foo.bar#baz()")))
-        .isInstanceOf(IllegalArgumentException.class);
-    assertThatThrownBy(() -> factory.create(ImmutableList.of("foo.bar#baz()", "a")))
         .isInstanceOf(IllegalArgumentException.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestInput.java

@@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJBigDecimalRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigDecimalRulesTestOutput.java

@@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJBigDecimalRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestInput.java

@@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJBigIntegerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBigIntegerRulesTestOutput.java

@@ -11,7 +11,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJBigIntegerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJByteRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJByteRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJByteRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJDoubleRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJDoubleRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJDoubleRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestInput.java

@@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJEnumerableRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Iterables.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJEnumerableRulesTestOutput.java

@@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJEnumerableRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Iterables.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJFloatRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJFloatRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJFloatRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJIntegerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJIntegerRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJIntegerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJLongRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJLongRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJLongRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestInput.java

@@ -23,7 +23,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJMapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         ArrayList.class,
         HashMap.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJMapRulesTestOutput.java

@@ -23,7 +23,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJMapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         ArrayList.class,
         HashMap.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJShortRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJShortRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJShortRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(offset(0), withPercentage(0));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestInput.java

@@ -13,7 +13,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Files.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJStringRulesTestOutput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJStringRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Files.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestInput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         assertThatExceptionOfType(Throwable.class),
         assertThatIOException(),

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJThrowingCallableRulesTestOutput.java

@@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssertJThrowingCallableRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         assertThatExceptionOfType(Throwable.class),
         assertThatIOException(),

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestInput.java

@@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssortedRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         HashSet.class,
         Iterables.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssortedRulesTestOutput.java

@@ -20,7 +20,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class AssortedRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         HashSet.class,
         Iterables.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestInput.java

@@ -8,7 +8,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(FixChoosers.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/BugCheckerRulesTestOutput.java

@@ -8,7 +8,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class BugCheckerRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(FixChoosers.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestInput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Iterables.class, Lists.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/CollectionRulesTestOutput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class CollectionRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Iterables.class, Lists.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestInput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Arrays.class,
         Collections.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ComparatorRulesTestOutput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ComparatorRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Arrays.class,
         Collections.class,

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class DoubleStreamRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/DoubleStreamRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class DoubleStreamRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestInput.java

@@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class EqualityRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Objects.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/EqualityRulesTestOutput.java

@@ -9,7 +9,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class EqualityRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Objects.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestInput.java

@@ -20,7 +20,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableListMultimapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Streams.class, flatteningToImmutableListMultimap(null, null), identity());
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListMultimapRulesTestOutput.java

@@ -20,7 +20,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableListMultimapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Streams.class, flatteningToImmutableListMultimap(null, null), identity());
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestInput.java

@@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableListRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Arrays.class, Collections.class, Comparator.class, Streams.class, naturalOrder());
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableListRulesTestOutput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableListRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Arrays.class, Collections.class, Comparator.class, Streams.class, naturalOrder());
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestInput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Collections.class, Streams.class, identity());
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMapRulesTestOutput.java

@@ -16,7 +16,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableMapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Collections.class, Streams.class, identity());
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestInput.java

@@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableMultisetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableMultisetRulesTestOutput.java

@@ -12,7 +12,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableMultisetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestInput.java

@@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSetMultimapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class, flatteningToImmutableSetMultimap(null, null));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetMultimapRulesTestOutput.java

@@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSetMultimapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class, flatteningToImmutableSetMultimap(null, null));
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestInput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Collections.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSetRulesTestOutput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Collections.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestInput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSortedMapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Stream.class, Streams.class, naturalOrder(), toImmutableSortedMap(null, null, null));
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMapRulesTestOutput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSortedMapRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Stream.class, Streams.class, naturalOrder(), toImmutableSortedMap(null, null, null));
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestInput.java

@@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSortedMultisetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedMultisetRulesTestOutput.java

@@ -15,7 +15,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSortedMultisetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestInput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSortedSetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/ImmutableSortedSetRulesTestOutput.java

@@ -14,7 +14,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class ImmutableSortedSetRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Arrays.class, Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class IntStreamRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/IntStreamRulesTestOutput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class IntStreamRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class);
   }
 

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestInput.java

@@ -17,7 +17,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Assertions.class,
         assertDoesNotThrow(() -> null),

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/JUnitToAssertJRulesTestOutput.java

@@ -21,7 +21,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class JUnitToAssertJRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
         Assertions.class,
         assertDoesNotThrow(() -> null),

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/LongStreamRulesTestInput.java

@@ -10,7 +10,7 @@ import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
 
 final class LongStreamRulesTest implements RefasterRuleCollectionTestCase {
   @Override
-  public ImmutableSet<?> elidedTypesAndStaticImports() {
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
     return ImmutableSet.of(Streams.class);
   }