WIP

.github/release.yml

@@ -1,29 +0,0 @@
-changelog:
-  exclude:
-    labels:
-      - "ignore-changelog"
-  categories:
-    - title: ":rocket: New Error Prone checks and Refaster templates"
-      labels:
-        - "new feature"
-    - title: ":sparkles: Improvements"
-      labels:
-        - "improvement"
-    - title: ":warning: Update considerations and deprecations"
-      labels:
-        - "breaking change"
-        - "deprecation"
-    - title: ":bug: Bug fixes"
-      labels:
-        - "bug"
-        - "bug fix"
-    - title: ":books: Documentation, test and build improvements"
-      labels:
-        - "documentation"
-        - "chore"
-    - title: ":chart_with_upwards_trend: Dependency upgrades"
-      labels:
-        - "dependencies"
-    - title: "Other changes"
-      labels:
-        - "*"

.github/workflows/build.yaml

@@ -4,8 +4,6 @@ on:
   push:
     branches:
       - 'master'
-permissions:
-  contents: read
 jobs:
   build:
     runs-on: ubuntu-22.04

.mvn/jvm.config

@@ -2,7 +2,6 @@
 -XX:SoftRefLRUPolicyMSPerMB=10
 -XX:+UseParallelGC
 --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
---add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED
@@ -10,4 +9,5 @@
 --add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
 --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+--add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
 --add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED

error-prone-contrib/README.md

@@ -33,16 +33,9 @@ Two other goals that one may find relevant:
   `target/pit-reports/index.html` files. For more information check the [PIT
   Maven plugin][pitest-maven].
 
-When running the project's tests in IntelliJ IDEA, you might see the following
-error:
-```
-java: exporting a package from system module jdk.compiler is not allowed with --release
-```
-
-If this happens, go to _Settings -> Build, Execution, Deployment -> Compiler ->
-Java Compiler_ and deselect the option _Use '--release' option for
-cross-compilation (Java 9 and later)_. See [IDEA-288052][idea-288052] for
-details.
+When loading the project in IntelliJ IDEA (and perhaps other IDEs) errors about
+the inaccessibility of `com.sun.tools.javac.*` classes may be reported. If this
+happens, configure your IDE to enable the `add-exports` profile.
 
 ### Contribution guidelines
 
@@ -342,9 +335,8 @@ Refaster's expressiveness:
 [forbidden-apis]: https://github.com/policeman-tools/forbidden-apis
 [fossa]: https://fossa.io
 [google-java-format]: https://github.com/google/google-java-format
-[idea-288052]: https://youtrack.jetbrains.com/issue/IDEA-288052
 [maven]: https://maven.apache.org
 [modernizer-maven-plugin]: https://github.com/gaul/modernizer-maven-plugin
+[sonarcloud]: https://sonarcloud.io
 [pitest]: https://pitest.org
 [pitest-maven]: https://pitest.org/quickstart/maven
-[sonarcloud]: https://sonarcloud.io

error-prone-contrib/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.1.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>error-prone-contrib</artifactId>
@@ -69,6 +69,11 @@
             <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.googlejavaformat</groupId>
             <artifactId>google-java-format</artifactId>
@@ -123,6 +128,11 @@
             <artifactId>jaxb-api</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.aspectj</groupId>
             <artifactId>aspectjweaver</artifactId>
@@ -168,6 +178,11 @@
             <artifactId>slf4j-api</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-core</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>

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

@@ -3,7 +3,9 @@ package tech.picnic.errorprone.bugpatterns;
 import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
+import static java.util.function.Predicate.not;
 
+import com.google.auto.common.AnnotationMirrors;
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
 import com.google.errorprone.BugPattern;
@@ -14,17 +16,24 @@ import com.google.errorprone.fixes.Fix;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.AnnotationMatcherUtils;
 import com.google.errorprone.matchers.Description;
+import com.google.errorprone.predicates.TypePredicate;
+import com.google.errorprone.predicates.TypePredicates;
+import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotationTree;
 import com.sun.source.tree.AssignmentTree;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.NewArrayTree;
 import com.sun.source.tree.Tree.Kind;
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Symbol;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Stream;
+import javax.lang.model.element.AnnotationValue;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
 /** A {@link BugChecker} which flags annotations that could be written more concisely. */
@@ -40,6 +49,7 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
   private static final ImmutableSet<BiFunction<AnnotationTree, VisitorState, Optional<Fix>>>
       FIX_FACTORIES =
           ImmutableSet.of(
+              CanonicalAnnotationSyntax::useSpringAlias,
               CanonicalAnnotationSyntax::dropRedundantParentheses,
               CanonicalAnnotationSyntax::dropRedundantValueAttribute,
               CanonicalAnnotationSyntax::dropRedundantCurlies);
@@ -54,6 +64,69 @@ public final class CanonicalAnnotationSyntax extends BugChecker implements Annot
         .orElse(Description.NO_MATCH);
   }
 
+  private static Optional<Fix> useSpringAlias(AnnotationTree tree, VisitorState state) {
+    boolean canDropAttributeName = tree.getArguments().size() == 1;
+
+    // XXX: The reduce is repeated. Fix.
+    return tree.getArguments().stream()
+        .flatMap(arg -> useBetterAlias(arg, canDropAttributeName, state).stream())
+        .reduce(SuggestedFix.Builder::merge)
+        .map(SuggestedFix.Builder::build);
+  }
+
+  private static Optional<SuggestedFix.Builder> useBetterAlias(
+      ExpressionTree tree, boolean canDropAttributeName, VisitorState state) {
+    if (tree.getKind() != Kind.ASSIGNMENT) {
+      return Optional.empty();
+    }
+
+    AssignmentTree assignment = (AssignmentTree) tree;
+    ExpressionTree element = assignment.getVariable();
+    if (canDropAttributeName == "value".equals(SourceCode.treeToString(element, state))) {
+      return Optional.empty();
+    }
+
+    return getAlias(element, state)
+        .map(
+            alias ->
+                "value".equals(alias)
+                    ? SuggestedFix.builder()
+                        .replace(
+                            assignment, SourceCode.treeToString(assignment.getExpression(), state))
+                    : SuggestedFix.builder().replace(element, alias));
+  }
+
+  // XXX: Also add support for non-default `AliasFor#annotation` values!
+  private static Optional<String> getAlias(ExpressionTree tree, VisitorState state) {
+    Symbol sym = ASTHelpers.getSymbol(tree);
+    if (sym == null) {
+      return Optional.empty();
+    }
+
+    // XXX: Extract.
+    TypePredicate isAliasFor =
+        TypePredicates.isExactType("org.springframework.core.annotation.AliasFor");
+    TypePredicate isAnnotation = TypePredicates.isExactType("java.lang.annotation.Annotation");
+
+    return sym.getAnnotationMirrors().stream()
+        .filter(m -> isAliasFor.apply(m.type, state))
+        .filter(
+            m ->
+                isAnnotation.apply(
+                    ((Attribute.Class) AnnotationMirrors.getAnnotationValue(m, "annotation"))
+                        .classType,
+                    state))
+        .flatMap(
+            m ->
+                Stream.of(
+                    AnnotationMirrors.getAnnotationValue(m, "value"),
+                    AnnotationMirrors.getAnnotationValue(m, "attribute")))
+        .map(AnnotationValue::getValue)
+        .map(Object::toString)
+        .filter(not(String::isEmpty))
+        .findFirst();
+  }
+
   private static Optional<Fix> dropRedundantParentheses(AnnotationTree tree, VisitorState state) {
     if (!tree.getArguments().isEmpty()) {
       /* Parentheses are necessary. */

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

@@ -4,10 +4,6 @@ import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.StandardTags.LIKELY_ERROR;
 import static com.google.errorprone.matchers.method.MethodMatchers.instanceMethod;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.type;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.unbound;
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.Iterables;
@@ -20,14 +16,11 @@ import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.suppliers.Suppliers;
-import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MemberReferenceTree;
 import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import reactor.core.publisher.Flux;
 
 /**
@@ -39,12 +32,11 @@ import reactor.core.publisher.Flux;
  * former interleaves values as they are emitted, yielding nondeterministic results. In most cases
  * {@link Flux#concatMap(Function)} should be preferred, as it produces consistent results and
  * avoids potentially saturating the thread pool on which subscription happens. If {@code
- * concatMap}'s sequential-subscription semantics are undesirable one should invoke a {@code
- * flatMap} or {@code flatMapSequential} overload with an explicit concurrency level.
+ * concatMap}'s single-subscription semantics are undesirable one should invoke a {@code flatMap} or
+ * {@code flatMapSequential} overload with an explicit concurrency level.
  *
- * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function,
- * java.util.function.Supplier)} is not flagged by this check because there is no clear alternative
- * to point to.
+ * <p>NB: The rarely-used overload {@link Flux#flatMap(Function, Function, Supplier)} is not flagged
+ * by this check because there is no clear alternative to point to.
  */
 @AutoService(BugChecker.class)
 @BugPattern(
@@ -58,16 +50,11 @@ public final class FluxFlatMapUsage extends BugChecker
     implements MethodInvocationTreeMatcher, MemberReferenceTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final String MAX_CONCURRENCY_ARG_NAME = "MAX_CONCURRENCY";
-  private static final Supplier<Type> FLUX =
-      Suppliers.typeFromString("reactor.core.publisher.Flux");
   private static final Matcher<ExpressionTree> FLUX_FLATMAP =
       instanceMethod()
-          .onDescendantOf(FLUX)
+          .onDescendantOf("reactor.core.publisher.Flux")
           .namedAnyOf("flatMap", "flatMapSequential")
           .withParameters(Function.class.getName());
-  private static final Supplier<Type> FLUX_OF_PUBLISHERS =
-      VisitorState.memoize(
-          generic(FLUX, subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
@@ -75,27 +62,14 @@ public final class FluxFlatMapUsage extends BugChecker
       return Description.NO_MATCH;
     }
 
-    SuggestedFix serializationFix = SuggestedFixes.renameMethodInvocation(tree, "concatMap", state);
-    SuggestedFix concurrencyCapFix =
-        SuggestedFix.builder()
-            .postfixWith(
-                Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
-            .build();
-
-    Description.Builder description = buildDescription(tree);
-
-    if (state.getTypes().isSubtype(ASTHelpers.getType(tree), FLUX_OF_PUBLISHERS.get(state))) {
-      /*
-       * Nested publishers may need to be subscribed to eagerly in order to avoid a deadlock, e.g.
-       * if they are produced by `Flux#groupBy`. In this case we suggest specifying an explicit
-       * concurrently bound in favour of sequential subscriptions using `Flux#concatMap`.
-       */
-      description.addFix(concurrencyCapFix).addFix(serializationFix);
-    } else {
-      description.addFix(serializationFix).addFix(concurrencyCapFix);
-    }
-
-    return description.build();
+    return buildDescription(tree)
+        .addFix(SuggestedFixes.renameMethodInvocation(tree, "concatMap", state))
+        .addFix(
+            SuggestedFix.builder()
+                .postfixWith(
+                    Iterables.getOnlyElement(tree.getArguments()), ", " + MAX_CONCURRENCY_ARG_NAME)
+                .build())
+        .build();
   }
 
   @Override

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

@@ -3,11 +3,9 @@ package tech.picnic.errorprone.bugpatterns;
 import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
 import static com.google.errorprone.BugPattern.StandardTags.FRAGILE_CODE;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.raw;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
 
 import com.google.auto.service.AutoService;
+import com.google.common.collect.Iterables;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
@@ -17,7 +15,9 @@ import com.google.errorprone.suppliers.Supplier;
 import com.google.errorprone.suppliers.Suppliers;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.MethodInvocationTree;
+import com.sun.source.tree.Tree;
 import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.List;
 import java.util.Optional;
 
 /** A {@link BugChecker} which flags nesting of {@link Optional Optionals}. */
@@ -31,13 +31,21 @@ import java.util.Optional;
 public final class NestedOptionals extends BugChecker implements MethodInvocationTreeMatcher {
   private static final long serialVersionUID = 1L;
   private static final Supplier<Type> OPTIONAL = Suppliers.typeFromClass(Optional.class);
-  private static final Supplier<Type> OPTIONAL_OF_OPTIONAL =
-      VisitorState.memoize(generic(OPTIONAL, subOf(raw(OPTIONAL))));
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    return state.getTypes().isSubtype(ASTHelpers.getType(tree), OPTIONAL_OF_OPTIONAL.get(state))
-        ? describeMatch(tree)
-        : Description.NO_MATCH;
+    return isOptionalOfOptional(tree, state) ? describeMatch(tree) : Description.NO_MATCH;
+  }
+
+  private static boolean isOptionalOfOptional(Tree tree, VisitorState state) {
+    Type optionalType = OPTIONAL.get(state);
+    Type type = ASTHelpers.getType(tree);
+    if (!ASTHelpers.isSubtype(type, optionalType, state)) {
+      return false;
+    }
+
+    List<Type> typeArguments = type.getTypeArguments();
+    return !typeArguments.isEmpty()
+        && ASTHelpers.isSubtype(Iterables.getOnlyElement(typeArguments), optionalType, state);
   }
 }

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

@@ -1,91 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugPattern.LinkType.NONE;
-import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
-import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
-import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.instanceMethod;
-
-import com.google.auto.service.AutoService;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.fixes.SuggestedFix;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.util.ASTHelpers;
-import com.sun.source.tree.ExpressionTree;
-import com.sun.source.tree.MethodInvocationTree;
-import java.util.function.BiFunction;
-import reactor.core.publisher.Mono;
-import tech.picnic.errorprone.bugpatterns.util.SourceCode;
-
-/**
- * A {@link BugChecker} which flags {@link Mono} operations that are known to be vacuous, given that
- * they are invoked on a {@link Mono} that is known not to complete empty.
- */
-@AutoService(BugChecker.class)
-@BugPattern(
-    summary = "Avoid vacuous operations on known non-empty `Mono`s",
-    linkType = NONE,
-    severity = WARNING,
-    tags = SIMPLIFICATION)
-// XXX: This check does not simplify `someFlux.defaultIfEmpty(T).{defaultIfEmpty(T),hasElements()}`,
-// as `someFlux.defaultIfEmpty(T)` yields a `Flux` rather than a `Mono`. Consider adding support for
-// these cases.
-// XXX: Given more advanced analysis many more expressions could be flagged. Consider
-// `Mono.just(someValue)`, `Flux.just(someNonEmptySequence)`,
-// `someMono.switchIfEmpty(someProvablyNonEmptyMono)` and many other variants.
-// XXX: Consider implementing a similar check for `Publisher`s that are known to complete without
-// 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.
-public final class NonEmptyMono extends BugChecker implements MethodInvocationTreeMatcher {
-  private static final long serialVersionUID = 1L;
-  private static final Matcher<ExpressionTree> MONO_SIZE_CHECK =
-      instanceMethod()
-          .onDescendantOf("reactor.core.publisher.Mono")
-          .namedAnyOf("defaultIfEmpty", "single", "switchIfEmpty");
-  private static final Matcher<ExpressionTree> NON_EMPTY_MONO =
-      anyOf(
-          instanceMethod()
-              .onDescendantOf("reactor.core.publisher.Flux")
-              .namedAnyOf(
-                  "all",
-                  "any",
-                  "collect",
-                  "collectList",
-                  "collectMap",
-                  "collectMultimap",
-                  "collectSortedList",
-                  "count",
-                  "elementAt",
-                  "hasElement",
-                  "hasElements",
-                  "last",
-                  "reduceWith",
-                  "single"),
-          instanceMethod()
-              .onDescendantOf("reactor.core.publisher.Flux")
-              .named("reduce")
-              .withParameters(Object.class.getName(), BiFunction.class.getName()),
-          instanceMethod()
-              .onDescendantOf("reactor.core.publisher.Mono")
-              .namedAnyOf("defaultIfEmpty", "hasElement", "single"));
-
-  @Override
-  public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-    if (!MONO_SIZE_CHECK.matches(tree, state)) {
-      return Description.NO_MATCH;
-    }
-
-    ExpressionTree receiver = ASTHelpers.getReceiver(tree);
-    if (!NON_EMPTY_MONO.matches(receiver, state)) {
-      return Description.NO_MATCH;
-    }
-
-    return describeMatch(
-        tree, SuggestedFix.replace(tree, SourceCode.treeToString(receiver, state)));
-  }
-}

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

@@ -1,13 +1,10 @@
 package tech.picnic.errorprone.bugpatterns;
 
-import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.errorprone.BugPattern.LinkType.NONE;
 import static com.google.errorprone.BugPattern.SeverityLevel.SUGGESTION;
 import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION;
 import static com.google.errorprone.matchers.Matchers.allOf;
-import static com.google.errorprone.matchers.Matchers.anyMethod;
 import static com.google.errorprone.matchers.Matchers.anyOf;
-import static com.google.errorprone.matchers.Matchers.argumentCount;
 import static com.google.errorprone.matchers.Matchers.isNonNullUsingDataflow;
 import static com.google.errorprone.matchers.Matchers.isSameType;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
@@ -16,9 +13,7 @@ import static com.google.errorprone.matchers.method.MethodMatchers.instanceMetho
 import static com.google.errorprone.matchers.method.MethodMatchers.staticMethod;
 
 import com.google.auto.service.AutoService;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
-import com.google.common.primitives.Primitives;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.ErrorProneFlags;
 import com.google.errorprone.VisitorState;
@@ -29,7 +24,6 @@ import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
 import com.google.errorprone.fixes.SuggestedFix;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
-import com.google.errorprone.suppliers.Suppliers;
 import com.sun.source.tree.BinaryTree;
 import com.sun.source.tree.CompoundAssignmentTree;
 import com.sun.source.tree.ExpressionTree;
@@ -47,7 +41,6 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.stream.Stream;
 import tech.picnic.errorprone.bugpatterns.util.MethodMatcherFactory;
 import tech.picnic.errorprone.bugpatterns.util.SourceCode;
 
@@ -76,30 +69,49 @@ public final class RedundantStringConversion extends BugChecker
       allOf(STRING, isNonNullUsingDataflow());
   private static final Matcher<ExpressionTree> NOT_FORMATTABLE =
       not(isSubtypeOf(Formattable.class));
-  private static final Matcher<MethodInvocationTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
+  private static final Matcher<ExpressionTree> WELL_KNOWN_STRING_CONVERSION_METHODS =
       anyOf(
-          instanceMethod()
-              .onDescendantOfAny(Object.class.getName())
+          instanceMethod().onDescendantOfAny(Object.class.getName()).named("toString"),
+          staticMethod()
+              .onClass(Objects.class.getName())
               .named("toString")
-              .withNoParameters(),
-          allOf(
-              argumentCount(1),
-              anyOf(
-                  staticMethod()
-                      .onClassAny(
-                          Stream.concat(
-                                  Primitives.allWrapperTypes().stream(), Stream.of(Objects.class))
-                              .map(Class::getName)
-                              .collect(toImmutableSet()))
-                      .named("toString"),
-                  allOf(
-                      staticMethod().onClass(String.class.getName()).named("valueOf"),
-                      not(
-                          anyMethod()
-                              .anyClass()
-                              .withAnyName()
-                              .withParametersOfType(
-                                  ImmutableList.of(Suppliers.arrayOf(Suppliers.CHAR_TYPE))))))));
+              .withParameters(Object.class.getName()),
+          staticMethod()
+              .onClass(String.class.getName())
+              .named("valueOf")
+              .withParameters(Object.class.getName()),
+          staticMethod()
+              .onClass(String.class.getName())
+              .named("valueOf")
+              .withParameters(String.class.getName()),
+          staticMethod()
+              .onClass(Byte.class.getName())
+              .named("toString")
+              .withParameters(byte.class.getName()),
+          staticMethod()
+              .onClass(Character.class.getName())
+              .named("toString")
+              .withParameters(char.class.getName()),
+          staticMethod()
+              .onClass(Short.class.getName())
+              .named("toString")
+              .withParameters(short.class.getName()),
+          staticMethod()
+              .onClass(Integer.class.getName())
+              .named("toString")
+              .withParameters(int.class.getName()),
+          staticMethod()
+              .onClass(Long.class.getName())
+              .named("toString")
+              .withParameters(long.class.getName()),
+          staticMethod()
+              .onClass(Float.class.getName())
+              .named("toString")
+              .withParameters(float.class.getName()),
+          staticMethod()
+              .onClass(Double.class.getName())
+              .named("toString")
+              .withParameters(double.class.getName()));
   private static final Matcher<ExpressionTree> STRINGBUILDER_APPEND_INVOCATION =
       instanceMethod()
           .onDescendantOf(StringBuilder.class.getName())
@@ -115,10 +127,17 @@ public final class RedundantStringConversion extends BugChecker
           staticMethod().onClass(String.class.getName()).named("format"),
           instanceMethod().onDescendantOf(Formatter.class.getName()).named("format"),
           instanceMethod()
-              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
+              .onDescendantOf(PrintStream.class.getName())
               .namedAnyOf("format", "printf"),
           instanceMethod()
-              .onDescendantOfAny(PrintStream.class.getName(), PrintWriter.class.getName())
+              .onDescendantOf(PrintStream.class.getName())
+              .namedAnyOf("print", "println")
+              .withParameters(Object.class.getName()),
+          instanceMethod()
+              .onDescendantOf(PrintWriter.class.getName())
+              .namedAnyOf("format", "printf"),
+          instanceMethod()
+              .onDescendantOf(PrintWriter.class.getName())
               .namedAnyOf("print", "println")
               .withParameters(Object.class.getName()),
           staticMethod()
@@ -137,7 +156,7 @@ public final class RedundantStringConversion extends BugChecker
           .onDescendantOf("org.slf4j.Logger")
           .namedAnyOf("trace", "debug", "info", "warn", "error");
 
-  private final Matcher<MethodInvocationTree> conversionMethodMatcher;
+  private final Matcher<ExpressionTree> conversionMethodMatcher;
 
   /** Instantiates the default {@link RedundantStringConversion}. */
   public RedundantStringConversion() {
@@ -167,7 +186,7 @@ public final class RedundantStringConversion extends BugChecker
 
     List<SuggestedFix.Builder> fixes = new ArrayList<>();
 
-    // XXX: Avoid trying to simplify the RHS twice.
+    // XXX: Not so nice: we try to simplify the RHS twice.
     ExpressionTree preferredRhs = trySimplify(rhs, state).orElse(rhs);
     if (STRING.matches(preferredRhs, state)) {
       tryFix(lhs, state, ANY_EXPR).ifPresent(fixes::add);
@@ -257,15 +276,15 @@ public final class RedundantStringConversion extends BugChecker
 
   // XXX: Write another check which checks that SLF4J patterns don't use `%s` and have a matching
   // number of arguments of the appropriate type. Also flag explicit conversions from `Throwable` to
-  // string as the last logger argument. Suggests either dropping the conversion or going with
+  // string as the last logger argument. Suggests either dropping the converison or going with
   // `Throwable#getMessage()` instead.
   private Optional<SuggestedFix.Builder> tryFixSlf4jLogger(
       List<? extends ExpressionTree> arguments, VisitorState state) {
     /*
-     * SLF4J treats the final argument to a log statement specially if it is a `Throwable`: it
+     * SLF4J treats the final argument to a log statement specially if it is a `Throwabe`: it
      * will always choose to render the associated stacktrace, even if the argument has a
      * matching `{}` placeholder. (In this case the `{}` will simply be logged verbatim.) So if
-     * a log statement's final argument is the string representation of a `Throwable`, then we
+     * a log statement's final argument is the string representation of a `Throwble`, then we
      * must not strip this explicit string conversion, as that would change the statement's
      * semantics.
      */
@@ -319,15 +338,11 @@ public final class RedundantStringConversion extends BugChecker
   }
 
   private Optional<ExpressionTree> trySimplify(ExpressionTree tree, VisitorState state) {
-    if (tree.getKind() != Kind.METHOD_INVOCATION) {
+    if (tree.getKind() != Kind.METHOD_INVOCATION || !conversionMethodMatcher.matches(tree, state)) {
       return Optional.empty();
     }
 
     MethodInvocationTree methodInvocation = (MethodInvocationTree) tree;
-    if (!conversionMethodMatcher.matches(methodInvocation, state)) {
-      return Optional.empty();
-    }
-
     switch (methodInvocation.getArguments().size()) {
       case 0:
         return trySimplifyNullaryMethod(methodInvocation, state);
@@ -368,8 +383,7 @@ public final class RedundantStringConversion extends BugChecker
         .orElse(Description.NO_MATCH);
   }
 
-  private static Matcher<MethodInvocationTree> createConversionMethodMatcher(
-      ErrorProneFlags flags) {
+  private static Matcher<ExpressionTree> createConversionMethodMatcher(ErrorProneFlags flags) {
     // XXX: ErrorProneFlags#getList splits by comma, but method signatures may also contain commas.
     // For this class methods accepting more than one argument are not valid, but still: not nice.
     return flags

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

@@ -66,8 +66,7 @@ public final class RequestMappingAnnotation extends BugChecker implements Method
                           isType(ANN_PACKAGE_PREFIX + "RequestAttribute"),
                           isType(ANN_PACKAGE_PREFIX + "RequestBody"),
                           isType(ANN_PACKAGE_PREFIX + "RequestHeader"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestParam"),
-                          isType(ANN_PACKAGE_PREFIX + "RequestPart"))),
+                          isType(ANN_PACKAGE_PREFIX + "RequestParam"))),
                   isSameType("java.io.InputStream"),
                   isSameType("java.time.ZoneId"),
                   isSameType("java.util.Locale"),

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

@@ -1,132 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static java.util.stream.Collectors.toCollection;
-
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.suppliers.Suppliers;
-import com.sun.tools.javac.code.BoundKind;
-import com.sun.tools.javac.code.Type;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.function.BiFunction;
-
-/**
- * A set of helper methods which together define a DSL for defining {@link Type types}.
- *
- * <p>These methods are meant to be statically imported. Example usage:
- *
- * <pre>{@code
- * Supplier<Type> type =
- *     VisitorState.memoize(
- *         generic(
- *             type("reactor.core.publisher.Flux"),
- *             subOf(generic(type("org.reactivestreams.Publisher"), unbound()))));
- * }</pre>
- *
- * This statement produces a memoized supplier of the type {@code Flux<? extends Publisher<?>>}.
- */
-public final class MoreTypes {
-  private MoreTypes() {}
-
-  /**
-   * Creates a supplier of the type with the given fully qualified name.
-   *
-   * <p>This method should only be used when building more complex types in combination with other
-   * {@link MoreTypes} methods. In other cases prefer directly calling {@link
-   * Suppliers#typeFromString(String)}.
-   *
-   * @param typeName The type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> type(String typeName) {
-    return Suppliers.typeFromString(typeName);
-  }
-
-  /**
-   * Creates a supplier of the described generic type.
-   *
-   * @param type The base type of interest.
-   * @param typeArgs The desired type arguments.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  // XXX: The given `type` should be a generic type, so perhaps `withParams` would be a better
-  // method name. But the DSL wouldn't look as nice that way.
-  @SafeVarargs
-  @SuppressWarnings("varargs")
-  public static Supplier<Type> generic(Supplier<Type> type, Supplier<Type>... typeArgs) {
-    return propagateNull(
-        type,
-        (state, baseType) -> {
-          List<Type> params =
-              Arrays.stream(typeArgs).map(s -> s.get(state)).collect(toCollection(ArrayList::new));
-          if (params.stream().anyMatch(Objects::isNull)) {
-            return null;
-          }
-
-          return state.getType(baseType, /* isArray= */ false, params);
-        });
-  }
-
-  /**
-   * Creates a raw (erased, non-generic) variant of the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> raw(Supplier<Type> type) {
-    return propagateNull(type, (state, baseType) -> baseType.tsym.erasure(state.getTypes()));
-  }
-
-  /**
-   * Creates a {@code ? super T} wildcard type, with {@code T} bound to the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> supOf(Supplier<Type> type) {
-    return propagateNull(
-        type,
-        (state, baseType) ->
-            new Type.WildcardType(baseType, BoundKind.SUPER, state.getSymtab().boundClass));
-  }
-
-  /**
-   * Creates a {@code ? extends T} wildcard type, with {@code T} bound to the given type.
-   *
-   * @param type The base type of interest.
-   * @return A supplier which returns the described type if available in the given state, and {@code
-   *     null} otherwise.
-   */
-  public static Supplier<Type> subOf(Supplier<Type> type) {
-    return propagateNull(
-        type,
-        (state, baseType) ->
-            new Type.WildcardType(
-                type.get(state), BoundKind.EXTENDS, state.getSymtab().boundClass));
-  }
-
-  /**
-   * Creates an unbound wildcard type ({@code ?}).
-   *
-   * @return A supplier which returns the described type.
-   */
-  public static Supplier<Type> unbound() {
-    return state ->
-        new Type.WildcardType(
-            state.getSymtab().objectType, BoundKind.UNBOUND, state.getSymtab().boundClass);
-  }
-
-  private static Supplier<Type> propagateNull(
-      Supplier<Type> type, BiFunction<VisitorState, Type, Type> transformer) {
-    return state ->
-        Optional.ofNullable(type.get(state)).map(t -> transformer.apply(state, t)).orElse(null);
-  }
-}

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/EqualityTemplates.java

@@ -41,11 +41,13 @@ final class EqualityTemplates {
   // non-null.
   static final class EqualsPredicate<T> {
     @BeforeTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> before(T v) {
       return e -> v.equals(e);
     }
 
     @AfterTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> after(T v) {
       return v::equals;
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/NullTemplates.java

@@ -9,38 +9,11 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Objects;
 import java.util.function.Predicate;
-import javax.annotation.Nullable;
 
 /** Refaster templates related to expressions dealing with (possibly) null values. */
 final class NullTemplates {
   private NullTemplates() {}
 
-  /** Prefer the {@code ==} operator over {@link Objects#isNull(Object)}. */
-  static final class IsNull {
-    @BeforeTemplate
-    boolean before(@Nullable Object object) {
-      return Objects.isNull(object);
-    }
-
-    @AfterTemplate
-    boolean after(@Nullable Object object) {
-      return object == null;
-    }
-  }
-
-  /** Prefer the {@code !=} operator over {@link Objects#nonNull(Object)}. */
-  static final class IsNotNull {
-    @BeforeTemplate
-    boolean before(@Nullable Object object) {
-      return Objects.nonNull(object);
-    }
-
-    @AfterTemplate
-    boolean after(@Nullable Object object) {
-      return object != null;
-    }
-  }
-
   /** Prefer {@link Objects#requireNonNullElse(Object, Object)} over the Guava alternative. */
   // XXX: This rule is not valid in case `second` is `@Nullable`: in that case the Guava variant
   // will return `null`, while the JDK variant will throw an NPE.
@@ -60,11 +33,13 @@ final class NullTemplates {
   /** Prefer {@link Objects#isNull(Object)} over the equivalent lambda function. */
   static final class IsNullFunction<T> {
     @BeforeTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> before() {
       return o -> o == null;
     }
 
     @AfterTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> after() {
       return Objects::isNull;
     }
@@ -73,11 +48,13 @@ final class NullTemplates {
   /** Prefer {@link Objects#nonNull(Object)} over the equivalent lambda function. */
   static final class NonNullFunction<T> {
     @BeforeTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> before() {
       return o -> o != null;
     }
 
     @AfterTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Predicate<T> after() {
       return Objects::nonNull;
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/OptionalTemplates.java

@@ -81,11 +81,13 @@ final class OptionalTemplates {
   // generalization. If/when Refaster is extended to understand this, delete the template above.
   static final class OptionalOrElseThrowMethodReference<T> {
     @BeforeTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Function<Optional<T>, T> before() {
       return Optional::get;
     }
 
     @AfterTemplate
+    @SuppressWarnings("NoFunctionalReturnType")
     Function<Optional<T>, T> after() {
       return Optional::orElseThrow;
     }

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplates.java

@@ -9,6 +9,7 @@ import io.reactivex.Flowable;
 import io.reactivex.Maybe;
 import io.reactivex.Observable;
 import io.reactivex.Single;
+import org.reactivestreams.Publisher;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -38,12 +39,12 @@ final class RxJava2AdapterTemplates {
    */
   static final class FlowableToFlux<T> {
     @BeforeTemplate
-    Flux<T> before(Flowable<T> flowable) {
+    Publisher<T> before(Flowable<T> flowable) {
       return Refaster.anyOf(
-          Flux.from(flowable),
+          flowable.compose(Flux::from),
           flowable.to(Flux::from),
           flowable.as(Flux::from),
-          RxJava2Adapter.flowableToFlux(flowable),
+          flowable.compose(RxJava2Adapter::flowableToFlux),
           flowable.to(RxJava2Adapter::flowableToFlux));
     }
 
@@ -59,11 +60,12 @@ final class RxJava2AdapterTemplates {
    */
   static final class FluxToFlowable<T> {
     @BeforeTemplate
-    Flowable<T> before(Flux<T> flux) {
+    Publisher<T> before(Flux<T> flux) {
       return Refaster.anyOf(
           Flowable.fromPublisher(flux),
+          flux.transform(Flowable::fromPublisher),
           flux.as(Flowable::fromPublisher),
-          RxJava2Adapter.fluxToFlowable(flux));
+          flux.transform(RxJava2Adapter::fluxToFlowable));
     }
 
     @AfterTemplate
@@ -130,11 +132,12 @@ final class RxJava2AdapterTemplates {
    */
   static final class MonoToFlowable<T> {
     @BeforeTemplate
-    Flowable<T> before(Mono<T> mono) {
+    Publisher<T> before(Mono<T> mono) {
       return Refaster.anyOf(
           Flowable.fromPublisher(mono),
+          mono.transform(Flowable::fromPublisher),
           mono.as(Flowable::fromPublisher),
-          RxJava2Adapter.monoToFlowable(mono));
+          mono.transform(RxJava2Adapter::monoToFlowable));
     }
 
     @AfterTemplate

error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/StringTemplates.java

@@ -13,9 +13,7 @@ import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Function;
 import javax.annotation.Nullable;
 
 /** Refaster templates related to expressions dealing with {@link String}s. */
@@ -108,40 +106,6 @@ final class StringTemplates {
     }
   }
 
-  /**
-   * Prefer direct invocation of {@link String#valueOf(Object)} over the indirection introduced by
-   * {@link Objects#toString(Object)}.
-   */
-  static final class StringValueOf {
-    @BeforeTemplate
-    String before(Object object) {
-      return Objects.toString(object);
-    }
-
-    @AfterTemplate
-    String after(Object object) {
-      return String.valueOf(object);
-    }
-  }
-
-  /**
-   * Prefer direct delegation to {@link String#valueOf(Object)} over the indirection introduced by
-   * {@link Objects#toString(Object)}.
-   */
-  // XXX: This template is analogous to `StringValueOf` above. Arguably this is its generalization.
-  // If/when Refaster is extended to understand this, delete the template above.
-  static final class StringValueOfMethodReference<T> {
-    @BeforeTemplate
-    Function<Object, String> before() {
-      return Objects::toString;
-    }
-
-    @AfterTemplate
-    Function<Object, String> after() {
-      return String::valueOf;
-    }
-  }
-
   /** Don't unnecessarily use the two-argument {@link String#substring(int, int)}. */
   static final class SubstringRemainder {
     @BeforeTemplate

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

@@ -11,6 +11,24 @@ final class CanonicalAnnotationSyntaxTest {
   private final BugCheckerRefactoringTestHelper refactoringTestHelper =
       BugCheckerRefactoringTestHelper.newInstance(CanonicalAnnotationSyntax.class, getClass());
 
+  // XXX: Merge with code below
+  @Test
+  public void testIdentificationSpring() {
+    compilationTestHelper
+        .addSourceLines(
+            "pkg/A.java",
+            "package pkg;",
+            "",
+            "import org.springframework.web.bind.annotation.RequestMapping;",
+            "",
+            "// BUG: Diagnostic contains:",
+            //            "@RequestMapping(path = \"/path\")",
+            "@RequestMapping(value = \"/path\", consumes = \"text/plain\")",
+            "class A {",
+            "}")
+        .doTest();
+  }
+
   @Test
   void identification() {
     compilationTestHelper

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

@@ -4,7 +4,6 @@ import static com.google.errorprone.BugCheckerRefactoringTestHelper.newInstance;
 
 import com.google.errorprone.BugCheckerRefactoringTestHelper;
 import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers;
-import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
 
@@ -34,14 +33,6 @@ final class FluxFlatMapUsageTest {
             "    Flux.just(1).flatMapSequential(Flux::just);",
             "    // BUG: Diagnostic contains:",
             "    Flux.just(1).<String>flatMapSequential(i -> Flux.just(String.valueOf(i)));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just);",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).<String>flatMap(i -> Flux.just(String.valueOf(i)));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just);",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1, 2).groupBy(i -> i).<String>flatMapSequential(i -> Flux.just(String.valueOf(i)));",
             "",
             "    Mono.just(1).flatMap(Mono::just);",
             "    Flux.just(1).concatMap(Flux::just);",
@@ -80,13 +71,9 @@ final class FluxFlatMapUsageTest {
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
-            "  private static final int MAX_CONCURRENCY = 8;",
-            "",
             "  void m() {",
             "    Flux.just(1).flatMap(Flux::just);",
             "    Flux.just(1).flatMapSequential(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just);",
             "  }",
             "}")
         .addOutputLines(
@@ -94,16 +81,12 @@ final class FluxFlatMapUsageTest {
             "import reactor.core.publisher.Flux;",
             "",
             "class A {",
-            "  private static final int MAX_CONCURRENCY = 8;",
-            "",
             "  void m() {",
             "    Flux.just(1).concatMap(Flux::just);",
             "    Flux.just(1).concatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just, MAX_CONCURRENCY);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just, MAX_CONCURRENCY);",
             "  }",
             "}")
-        .doTest(TestMode.TEXT_MATCH);
+        .doTest();
   }
 
   @Test
@@ -120,8 +103,6 @@ final class FluxFlatMapUsageTest {
             "  void m() {",
             "    Flux.just(1).flatMap(Flux::just);",
             "    Flux.just(1).flatMapSequential(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).flatMapSequential(Flux::just);",
             "  }",
             "}")
         .addOutputLines(
@@ -134,10 +115,8 @@ final class FluxFlatMapUsageTest {
             "  void m() {",
             "    Flux.just(1).flatMap(Flux::just, MAX_CONCURRENCY);",
             "    Flux.just(1).flatMapSequential(Flux::just, MAX_CONCURRENCY);",
-            "    Flux.just(1, 2).groupBy(i -> i).concatMap(Flux::just);",
-            "    Flux.just(1, 2).groupBy(i -> i).concatMap(Flux::just);",
             "  }",
             "}")
-        .doTest(TestMode.TEXT_MATCH);
+        .doTest();
   }
 }

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

@@ -1,155 +0,0 @@
-package tech.picnic.errorprone.bugpatterns;
-
-import static com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode.TEXT_MATCH;
-
-import com.google.errorprone.BugCheckerRefactoringTestHelper;
-import com.google.errorprone.CompilationTestHelper;
-import org.junit.jupiter.api.Test;
-
-final class NonEmptyMonoTest {
-  private final CompilationTestHelper compilationTestHelper =
-      CompilationTestHelper.newInstance(NonEmptyMono.class, getClass());
-  private final BugCheckerRefactoringTestHelper refactoringTestHelper =
-      BugCheckerRefactoringTestHelper.newInstance(NonEmptyMono.class, getClass());
-
-  @Test
-  void identification() {
-    compilationTestHelper
-        .addSourceLines(
-            "A.java",
-            "import static com.google.common.collect.ImmutableList.toImmutableList;",
-            "import static java.util.function.Function.identity;",
-            "",
-            "import com.google.common.collect.ImmutableList;",
-            "import com.google.common.collect.ImmutableMap;",
-            "import java.util.ArrayList;",
-            "import java.util.HashMap;",
-            "import java.util.List;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.core.publisher.Mono;",
-            "",
-            "class A {",
-            "  void m() {",
-            "    Mono.just(1).defaultIfEmpty(2);",
-            "    Mono.just(1).single();",
-            "    Mono.just(1).switchIfEmpty(Mono.just(2));",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).all(x -> true).defaultIfEmpty(true);",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).any(x -> true).single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collect(toImmutableList()).switchIfEmpty(Mono.just(ImmutableList.of()));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collect(ArrayList::new, List::add).defaultIfEmpty(new ArrayList<>());",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectList().single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectMap(identity()).switchIfEmpty(Mono.just(ImmutableMap.of()));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectMap(identity(), identity()).defaultIfEmpty(ImmutableMap.of());",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectMap(identity(), identity(), HashMap::new).single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectMultimap(identity()).switchIfEmpty(Mono.just(ImmutableMap.of()));",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectMultimap(identity(), identity()).defaultIfEmpty(ImmutableMap.of());",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectMultimap(identity(), identity(), HashMap::new).single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectSortedList().defaultIfEmpty(ImmutableList.of());",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).collectSortedList((o1, o2) -> 0).single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).count().switchIfEmpty(Mono.just(2L));",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).elementAt(0).defaultIfEmpty(1);",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).elementAt(0, 2).single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).hasElement(2).switchIfEmpty(Mono.just(true));",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).hasElements().defaultIfEmpty(true);",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).last().single();",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).last(2).switchIfEmpty(Mono.just(3));",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).reduceWith(() -> 0, Integer::sum).defaultIfEmpty(2);",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).single().single();",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).single(2).switchIfEmpty(Mono.just(3));",
-            "",
-            "    Flux.just(1).reduce(Integer::sum).defaultIfEmpty(2);",
-            "    // BUG: Diagnostic contains:",
-            "    Flux.just(1).reduce(2, Integer::sum).single();",
-            "",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.just(1).defaultIfEmpty(1).switchIfEmpty(Mono.just(2));",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.just(1).hasElement().defaultIfEmpty(true);",
-            "    // BUG: Diagnostic contains:",
-            "    Mono.just(1).single().single();",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  @Test
-  void replacement() {
-    refactoringTestHelper
-        .addInputLines(
-            "A.java",
-            "import static com.google.common.collect.ImmutableList.toImmutableList;",
-            "",
-            "import com.google.common.collect.ImmutableList;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.core.publisher.Mono;",
-            "",
-            "class A {",
-            "  void m() {",
-            "    Flux.just(1).collect(toImmutableList()).single();",
-            "    Flux.just(1).collect(toImmutableList()).defaultIfEmpty(ImmutableList.of());",
-            "    Flux.just(1).collect(toImmutableList()).switchIfEmpty(Mono.just(ImmutableList.of()));",
-            "",
-            "    Mono.just(2).hasElement().single();",
-            "    Mono.just(2).hasElement().defaultIfEmpty(true);",
-            "    Mono.just(2).hasElement().switchIfEmpty(Mono.just(true));",
-            "  }",
-            "}")
-        .addOutputLines(
-            "A.java",
-            "import static com.google.common.collect.ImmutableList.toImmutableList;",
-            "",
-            "import com.google.common.collect.ImmutableList;",
-            "import reactor.core.publisher.Flux;",
-            "import reactor.core.publisher.Mono;",
-            "",
-            "class A {",
-            "  void m() {",
-            "    Flux.just(1).collect(toImmutableList());",
-            "    Flux.just(1).collect(toImmutableList());",
-            "    Flux.just(1).collect(toImmutableList());",
-            "",
-            "    Mono.just(2).hasElement();",
-            "    Mono.just(2).hasElement();",
-            "    Mono.just(2).hasElement();",
-            "  }",
-            "}")
-        .doTest(TEXT_MATCH);
-  }
-}

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

@@ -69,14 +69,9 @@ final class RedundantStringConversionTest {
             "    // BUG: Diagnostic contains:",
             "    s += String.valueOf(i);",
             "    // BUG: Diagnostic contains:",
-            "    s += String.valueOf(0);",
-            "    // BUG: Diagnostic contains:",
             "    s += String.valueOf((String) null);",
             "    s += String.valueOf(null);",
             "    s += String.valueOf(new char[0]);",
-            "    s += String.valueOf(new char[0], 0, 0);",
-            "    // BUG: Diagnostic contains:",
-            "    s += Boolean.toString(false);",
             "    // BUG: Diagnostic contains:",
             "    s += Byte.toString((byte) 0);",
             "    // BUG: Diagnostic contains:",
@@ -126,12 +121,9 @@ final class RedundantStringConversionTest {
             "      // BUG: Diagnostic contains:",
             "      s + String.valueOf(i),",
             "      // BUG: Diagnostic contains:",
-            "      s + String.valueOf(0),",
-            "      // BUG: Diagnostic contains:",
             "      s + String.valueOf((String) null),",
             "      s + String.valueOf(null),",
             "      s + String.valueOf(new char[0]),",
-            "      s + String.valueOf(new char[0], 0, 0),",
             "      //",
             "      42 + this.toString(),",
             "      42 + super.toString(),",
@@ -142,7 +134,6 @@ final class RedundantStringConversionTest {
             "      42 + String.valueOf((String) null),",
             "      42 + String.valueOf(null),",
             "      42 + String.valueOf(new char[0]),",
-            "      42 + String.valueOf(new char[0], 0, 0),",
             "",
             "      // BUG: Diagnostic contains:",
             "      this.toString() + s,",
@@ -153,24 +144,19 @@ final class RedundantStringConversionTest {
             "      // BUG: Diagnostic contains:",
             "      String.valueOf(i) + s,",
             "      // BUG: Diagnostic contains:",
-            "      String.valueOf(0) + s,",
-            "      // BUG: Diagnostic contains:",
             "      String.valueOf((String) null) + s,",
             "      String.valueOf(null) + s,",
             "      String.valueOf(new char[0]) + s,",
-            "      String.valueOf(new char[0], 0, 0) + s,",
             "      //",
             "      this.toString() + 42,",
             "      super.toString() + 42,",
             "      i.toString() + 42,",
             "      i.toString(16) + 42,",
             "      String.valueOf(i) + 42,",
-            "      String.valueOf(0) + 42,",
             "      // BUG: Diagnostic contains:",
             "      String.valueOf((String) null) + 42,",
             "      String.valueOf(null) + 42,",
             "      String.valueOf(new char[0]) + 42,",
-            "      String.valueOf(new char[0], 0, 0) + 42,",
             "",
             "      // BUG: Diagnostic contains:",
             "      this.toString() + this.toString(),",
@@ -181,12 +167,9 @@ final class RedundantStringConversionTest {
             "      // BUG: Diagnostic contains:",
             "      String.valueOf(i) + String.valueOf(i),",
             "      // BUG: Diagnostic contains:",
-            "      String.valueOf(0) + String.valueOf(0),",
-            "      // BUG: Diagnostic contains:",
             "      String.valueOf((String) null) + String.valueOf((String) null),",
             "      String.valueOf(null) + String.valueOf(null),",
             "      String.valueOf(new char[0]) + String.valueOf(new char[0]),",
-            "      String.valueOf(new char[0], 0, 0) + String.valueOf(new char[0], 0, 0),",
             "    };",
             "  }",
             "",
@@ -221,12 +204,9 @@ final class RedundantStringConversionTest {
             "    // BUG: Diagnostic contains:",
             "    sb.append(String.valueOf(i));",
             "    // BUG: Diagnostic contains:",
-            "    sb.append(String.valueOf(0));",
-            "    // BUG: Diagnostic contains:",
             "    sb.append(String.valueOf((String) null));",
             "    sb.append(String.valueOf(null));",
             "    sb.append(String.valueOf(new char[0]));",
-            "    sb.append(String.valueOf(new char[0], 0, 0));",
             "    sb.append(s);",
             "    sb.append(\"constant\");",
             "",
@@ -238,12 +218,9 @@ final class RedundantStringConversionTest {
             "    // BUG: Diagnostic contains:",
             "    sb.insert(0, String.valueOf(i));",
             "    // BUG: Diagnostic contains:",
-            "    sb.insert(0, String.valueOf(0));",
-            "    // BUG: Diagnostic contains:",
             "    sb.insert(0, String.valueOf((String) null));",
             "    sb.insert(0, String.valueOf(null));",
             "    sb.insert(0, String.valueOf(new char[0]));",
-            "    sb.insert(0, String.valueOf(new char[0], 0, 0));",
             "    sb.insert(0, s);",
             "    sb.insert(0, \"constant\");",
             "",
@@ -457,8 +434,6 @@ final class RedundantStringConversionTest {
             "      // BUG: Diagnostic contains:",
             "      s + String.valueOf(b),",
             "      // BUG: Diagnostic contains:",
-            "      s + Boolean.toString(false),",
-            "      // BUG: Diagnostic contains:",
             "      s + Byte.toString((byte) 0),",
             "      // BUG: Diagnostic contains:",
             "      s + Character.toString((char) 0),",

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

@@ -30,7 +30,6 @@ final class RequestMappingAnnotationTest {
             "import org.springframework.web.bind.annotation.RequestHeader;",
             "import org.springframework.web.bind.annotation.RequestMapping;",
             "import org.springframework.web.bind.annotation.RequestParam;",
-            "import org.springframework.web.bind.annotation.RequestPart;",
             "import org.springframework.web.context.request.NativeWebRequest;",
             "import org.springframework.web.context.request.WebRequest;",
             "import org.springframework.web.server.ServerWebExchange;",
@@ -61,9 +60,6 @@ final class RequestMappingAnnotationTest {
             "  A properRequestParam(@RequestParam String param);",
             "",
             "  @RequestMapping",
-            "  A properRequestPart(@RequestPart String part);",
-            "",
-            "  @RequestMapping",
             "  A properInputStream(InputStream input);",
             "",
             "  @RequestMapping",

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

@@ -1,185 +0,0 @@
-package tech.picnic.errorprone.bugpatterns.util;
-
-import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.generic;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.raw;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.subOf;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.supOf;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.type;
-import static tech.picnic.errorprone.bugpatterns.util.MoreTypes.unbound;
-
-import com.google.common.collect.ImmutableSet;
-import com.google.errorprone.BugPattern;
-import com.google.errorprone.CompilationTestHelper;
-import com.google.errorprone.VisitorState;
-import com.google.errorprone.bugpatterns.BugChecker;
-import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher;
-import com.google.errorprone.matchers.Description;
-import com.google.errorprone.suppliers.Supplier;
-import com.google.errorprone.util.ASTHelpers;
-import com.google.errorprone.util.Signatures;
-import com.sun.source.tree.MethodInvocationTree;
-import com.sun.tools.javac.code.Type;
-import java.util.ArrayList;
-import java.util.List;
-import org.junit.jupiter.api.Test;
-
-final class MoreTypesTest {
-  private static final ImmutableSet<Supplier<Type>> TYPES =
-      ImmutableSet.of(
-          type("java.lang.Nonexistent"),
-          type("java.lang.String"),
-          type("java.lang.Number"),
-          supOf(type("java.lang.Number")),
-          subOf(type("java.lang.Number")),
-          type("java.lang.Integer"),
-          supOf(type("java.lang.Integer")),
-          subOf(type("java.lang.Integer")),
-          type("java.util.Optional"),
-          raw(type("java.util.Optional")),
-          generic(type("java.util.Optional"), unbound()),
-          generic(type("java.util.Optional"), type("java.lang.Number")),
-          type("java.util.Collection"),
-          raw(type("java.util.Collection")),
-          generic(type("java.util.Collection"), unbound()),
-          generic(type("java.util.Collection"), type("java.lang.Number")),
-          generic(type("java.util.Collection"), supOf(type("java.lang.Number"))),
-          generic(type("java.util.Collection"), subOf(type("java.lang.Number"))),
-          generic(type("java.util.Collection"), type("java.lang.Integer")),
-          generic(type("java.util.Collection"), supOf(type("java.lang.Integer"))),
-          generic(type("java.util.Collection"), subOf(type("java.lang.Integer"))),
-          type("java.util.List"),
-          raw(type("java.util.List")),
-          generic(type("java.util.List"), unbound()),
-          generic(type("java.util.List"), type("java.lang.Number")),
-          generic(type("java.util.List"), supOf(type("java.lang.Number"))),
-          generic(type("java.util.List"), subOf(type("java.lang.Number"))),
-          generic(type("java.util.List"), type("java.lang.Integer")),
-          generic(type("java.util.List"), supOf(type("java.lang.Integer"))),
-          generic(type("java.util.List"), subOf(type("java.lang.Integer"))),
-          generic(
-              type("java.util.Map"),
-              type("java.lang.String"),
-              subOf(generic(type("java.util.Collection"), supOf(type("java.lang.Short"))))));
-
-  @Test
-  void matcher() {
-    CompilationTestHelper.newInstance(SubtypeFlagger.class, getClass())
-        .addSourceLines(
-            "/A.java",
-            "import java.util.Collection;",
-            "import java.util.List;",
-            "import java.util.Map;",
-            "import java.util.Optional;",
-            "import java.util.Set;",
-            "",
-            "class A<S, T> {",
-            "  void m() {",
-            "    Object object = factory();",
-            "    A a = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Number, ? super Number, Integer, ? super Integer]",
-            "    int integer = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [String]",
-            "    String string = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Optional]",
-            "    Optional rawOptional = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>]",
-            "    Optional<S> optionalOfS = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>]",
-            "    Optional<T> optionalOfT = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>, Optional<Number>]",
-            "    Optional<Number> optionalOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Optional, Optional<?>]",
-            "    Optional<Integer> optionalOfInteger = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Collection]",
-            "    Collection rawCollection = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<Number>, Collection<? super",
-            "    // Number>, Collection<? extends Number>, Collection<? super Integer>]",
-            "    Collection<Number> collectionOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>,",
-            "    // Collection<Integer>, Collection<? super Integer>, Collection<? extends Integer>]",
-            "    Collection<Integer> collectionOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>]",
-            "    Collection<Short> collectionOfShort = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Collection, List]",
-            "    List rawList = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<Number>, Collection<? super",
-            "    // Number>, Collection<? extends Number>, Collection<? super Integer>, List, List<?>,",
-            "    // List<Number>, List<? super Number>, List<? extends Number>, List<? super Integer>]",
-            "    List<Number> listOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>,",
-            "    // Collection<Integer>, Collection<? super Integer>, Collection<? extends Integer>, List,",
-            "    // List<?>, List<? extends Number>, List<Integer>, List<? super Integer>, List<? extends",
-            "    // Integer>]",
-            "    List<Integer> listOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>, List,",
-            "    // List<?>, List<? extends Number>]",
-            "    List<Short> listOfShort = factory();",
-            "",
-            "    // BUG: Diagnostic contains: [Collection]",
-            "    Set rawSet = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<Number>, Collection<? super",
-            "    // Number>, Collection<? extends Number>, Collection<? super Integer>]",
-            "    Set<Number> setOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>,",
-            "    // Collection<Integer>, Collection<? super Integer>, Collection<? extends Integer>]",
-            "    Set<Integer> setOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Collection, Collection<?>, Collection<? extends Number>]",
-            "    Set<Short> setOfShort = factory();",
-            "",
-            "    Map rawMap = factory();",
-            "    Map<Number, Collection<Number>> mapFromNumberToCollectionOfNumber = factory();",
-            "    Map<Number, Collection<Short>> mapFromNumberToCollectionOfShort = factory();",
-            "    Map<Number, Collection<Integer>> mapFromNumberToCollectionOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, Collection<Number>> mapFromStringToCollectionOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, Collection<Short>> mapFromStringToCollectionOfShort = factory();",
-            "    Map<String, Collection<Integer>> mapFromStringToCollectionOfInteger = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, List<Number>> mapFromStringToListOfNumber = factory();",
-            "    // BUG: Diagnostic contains: [Map<String, ? extends Collection<? super Short>>]",
-            "    Map<String, List<Short>> mapFromStringToListOfShort = factory();",
-            "    Map<String, List<Integer>> mapFromStringToListOfInteger = factory();",
-            "  }",
-            "",
-            "  private <T> T factory() {",
-            "    return null;",
-            "  }",
-            "}")
-        .doTest();
-  }
-
-  /**
-   * A {@link BugChecker} which flags method invocations that are a subtype of any type contained in
-   * {@link #TYPES}.
-   */
-  @BugPattern(summary = "Flags invocations of methods with select return types", severity = ERROR)
-  public static final class SubtypeFlagger extends BugChecker
-      implements MethodInvocationTreeMatcher {
-    private static final long serialVersionUID = 1L;
-
-    @Override
-    public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
-      Type treeType = ASTHelpers.getType(tree);
-
-      List<String> matches = new ArrayList<>();
-
-      for (Supplier<Type> type : TYPES) {
-        Type testType = type.get(state);
-        if (testType != null && state.getTypes().isSubtype(treeType, testType)) {
-          matches.add(Signatures.prettyType(testType));
-        }
-      }
-
-      return matches.isEmpty()
-          ? Description.NO_MATCH
-          : buildDescription(tree).setMessage(matches.toString()).build();
-    }
-  }
-}

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/NullTemplatesTestInput.java

@@ -2,7 +2,6 @@ package tech.picnic.errorprone.refastertemplates;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
-import java.util.Objects;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;
 
@@ -12,14 +11,6 @@ final class NullTemplatesTest implements RefasterTemplateTestCase {
     return ImmutableSet.of(MoreObjects.class);
   }
 
-  boolean testIsNull() {
-    return Objects.isNull("foo");
-  }
-
-  boolean testIsNotNull() {
-    return Objects.nonNull("foo");
-  }
-
   String testRequireNonNullElse() {
     return MoreObjects.firstNonNull("foo", "bar");
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/NullTemplatesTestOutput.java

@@ -14,14 +14,6 @@ final class NullTemplatesTest implements RefasterTemplateTestCase {
     return ImmutableSet.of(MoreObjects.class);
   }
 
-  boolean testIsNull() {
-    return "foo" == null;
-  }
-
-  boolean testIsNotNull() {
-    return "foo" != null;
-  }
-
   String testRequireNonNullElse() {
     return requireNonNullElse("foo", "bar");
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplatesTestInput.java

@@ -7,6 +7,8 @@ import io.reactivex.Flowable;
 import io.reactivex.Maybe;
 import io.reactivex.Observable;
 import io.reactivex.Single;
+import java.util.Arrays;
+import org.reactivestreams.Publisher;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -19,20 +21,24 @@ final class RxJava2AdapterTemplatesTest implements RefasterTemplateTestCase {
         Completable.complete().to(RxJava2Adapter::completableToMono));
   }
 
-  ImmutableSet<Flux<Integer>> testFlowableToFlux() {
-    return ImmutableSet.of(
-        Flux.from(Flowable.just(1)),
-        Flowable.just(2).to(Flux::from),
-        Flowable.just(3).as(Flux::from),
-        RxJava2Adapter.flowableToFlux(Flowable.just(4)),
-        Flowable.just(5).to(RxJava2Adapter::flowableToFlux));
+  ImmutableSet<Publisher<Integer>> testFlowableToFlux() {
+    // The `Arrays.asList` is to avoid confusing `javac`; `ImmutableSet.of` uses varargs from the
+    // seventh parameter onwards.
+    return ImmutableSet.copyOf(
+        Arrays.asList(
+            Flowable.just(1).compose(Flux::from),
+            Flowable.just(2).to(Flux::from),
+            Flowable.just(3).as(Flux::from),
+            Flowable.just(4).compose(RxJava2Adapter::flowableToFlux),
+            Flowable.just(5).<Publisher<Integer>>to(RxJava2Adapter::flowableToFlux)));
   }
 
-  ImmutableSet<Flowable<String>> testFluxToFlowable() {
+  ImmutableSet<Publisher<String>> testFluxToFlowable() {
     return ImmutableSet.of(
         Flowable.fromPublisher(Flux.just("foo")),
-        Flux.just("bar").as(Flowable::fromPublisher),
-        RxJava2Adapter.fluxToFlowable(Flux.just("baz")));
+        Flux.just("bar").transform(Flowable::fromPublisher),
+        Flux.just("baz").as(Flowable::fromPublisher),
+        Flux.just("qux").transform(RxJava2Adapter::fluxToFlowable));
   }
 
   ImmutableSet<Observable<Integer>> testFluxToObservable() {
@@ -55,11 +61,12 @@ final class RxJava2AdapterTemplatesTest implements RefasterTemplateTestCase {
         RxJava2Adapter.monoToCompletable(Mono.empty()));
   }
 
-  ImmutableSet<Flowable<Integer>> testMonoToFlowable() {
+  ImmutableSet<Publisher<Integer>> testMonoToFlowable() {
     return ImmutableSet.of(
         Flowable.fromPublisher(Mono.just(1)),
-        Mono.just(2).as(Flowable::fromPublisher),
-        RxJava2Adapter.monoToFlowable(Mono.just(3)));
+        Mono.just(2).transform(Flowable::fromPublisher),
+        Mono.just(3).as(Flowable::fromPublisher),
+        Mono.just(4).transform(RxJava2Adapter::monoToFlowable));
   }
 
   Maybe<String> testMonoToMaybe() {

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplatesTestOutput.java

@@ -7,6 +7,8 @@ import io.reactivex.Flowable;
 import io.reactivex.Maybe;
 import io.reactivex.Observable;
 import io.reactivex.Single;
+import java.util.Arrays;
+import org.reactivestreams.Publisher;
 import reactor.adapter.rxjava.RxJava2Adapter;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -19,20 +21,24 @@ final class RxJava2AdapterTemplatesTest implements RefasterTemplateTestCase {
         Completable.complete().as(RxJava2Adapter::completableToMono));
   }
 
-  ImmutableSet<Flux<Integer>> testFlowableToFlux() {
-    return ImmutableSet.of(
-        Flowable.just(1).as(RxJava2Adapter::flowableToFlux),
-        Flowable.just(2).as(RxJava2Adapter::flowableToFlux),
-        Flowable.just(3).as(RxJava2Adapter::flowableToFlux),
-        Flowable.just(4).as(RxJava2Adapter::flowableToFlux),
-        Flowable.just(5).as(RxJava2Adapter::flowableToFlux));
+  ImmutableSet<Publisher<Integer>> testFlowableToFlux() {
+    // The `Arrays.asList` is to avoid confusing `javac`; `ImmutableSet.of` uses varargs from the
+    // seventh parameter onwards.
+    return ImmutableSet.copyOf(
+        Arrays.asList(
+            Flowable.just(1).as(RxJava2Adapter::flowableToFlux),
+            Flowable.just(2).as(RxJava2Adapter::flowableToFlux),
+            Flowable.just(3).as(RxJava2Adapter::flowableToFlux),
+            Flowable.just(4).as(RxJava2Adapter::flowableToFlux),
+            Flowable.just(5).as(RxJava2Adapter::flowableToFlux)));
   }
 
-  ImmutableSet<Flowable<String>> testFluxToFlowable() {
+  ImmutableSet<Publisher<String>> testFluxToFlowable() {
     return ImmutableSet.of(
         Flux.just("foo").as(RxJava2Adapter::fluxToFlowable),
         Flux.just("bar").as(RxJava2Adapter::fluxToFlowable),
-        Flux.just("baz").as(RxJava2Adapter::fluxToFlowable));
+        Flux.just("baz").as(RxJava2Adapter::fluxToFlowable),
+        Flux.just("qux").as(RxJava2Adapter::fluxToFlowable));
   }
 
   ImmutableSet<Observable<Integer>> testFluxToObservable() {
@@ -55,11 +61,12 @@ final class RxJava2AdapterTemplatesTest implements RefasterTemplateTestCase {
         Mono.empty().as(RxJava2Adapter::monoToCompletable));
   }
 
-  ImmutableSet<Flowable<Integer>> testMonoToFlowable() {
+  ImmutableSet<Publisher<Integer>> testMonoToFlowable() {
     return ImmutableSet.of(
         Mono.just(1).as(RxJava2Adapter::monoToFlowable),
         Mono.just(2).as(RxJava2Adapter::monoToFlowable),
-        Mono.just(3).as(RxJava2Adapter::monoToFlowable));
+        Mono.just(3).as(RxJava2Adapter::monoToFlowable),
+        Mono.just(4).as(RxJava2Adapter::monoToFlowable));
   }
 
   Maybe<String> testMonoToMaybe() {

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/StringTemplatesTestInput.java

@@ -10,9 +10,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Streams;
 import java.util.Arrays;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Function;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;
 
@@ -20,7 +18,7 @@ final class StringTemplatesTest implements RefasterTemplateTestCase {
   @Override
   public ImmutableSet<?> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
-        Arrays.class, Joiner.class, Objects.class, Stream.class, Streams.class, joining(), UTF_8);
+        Arrays.class, Joiner.class, Stream.class, Streams.class, joining(), UTF_8);
   }
 
   ImmutableSet<Boolean> testStringIsEmpty() {
@@ -61,14 +59,6 @@ final class StringTemplatesTest implements RefasterTemplateTestCase {
         ImmutableList.of("foo", "bar").stream().collect(joining("f")));
   }
 
-  String testStringValueOf() {
-    return Objects.toString("foo");
-  }
-
-  Function<Object, String> testStringValueOfMethodReference() {
-    return Objects::toString;
-  }
-
   String testSubstringRemainder() {
     return "foo".substring(1, "foo".length());
   }

error-prone-contrib/src/test/resources/tech/picnic/errorprone/refastertemplates/StringTemplatesTestOutput.java

@@ -11,9 +11,7 @@ import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Streams;
 import java.util.Arrays;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.function.Function;
 import java.util.stream.Stream;
 import tech.picnic.errorprone.refaster.test.RefasterTemplateTestCase;
 
@@ -21,7 +19,7 @@ final class StringTemplatesTest implements RefasterTemplateTestCase {
   @Override
   public ImmutableSet<?> elidedTypesAndStaticImports() {
     return ImmutableSet.of(
-        Arrays.class, Joiner.class, Objects.class, Stream.class, Streams.class, joining(), UTF_8);
+        Arrays.class, Joiner.class, Stream.class, Streams.class, joining(), UTF_8);
   }
 
   ImmutableSet<Boolean> testStringIsEmpty() {
@@ -61,14 +59,6 @@ final class StringTemplatesTest implements RefasterTemplateTestCase {
         String.join("f", ImmutableList.of("foo", "bar")));
   }
 
-  String testStringValueOf() {
-    return String.valueOf("foo");
-  }
-
-  Function<Object, String> testStringValueOfMethodReference() {
-    return String::valueOf;
-  }
-
   String testSubstringRemainder() {
     return "foo".substring(1);
   }

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>tech.picnic.error-prone-support</groupId>
     <artifactId>error-prone-support</artifactId>
-    <version>0.2.1-SNAPSHOT</version>
+    <version>0.1.1-SNAPSHOT</version>
     <packaging>pom</packaging>
 
     <name>Picnic :: Error Prone Support</name>
@@ -87,7 +87,6 @@
             -XX:SoftRefLRUPolicyMSPerMB=10
             -XX:+UseParallelGC
             --add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED
-            --add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
             --add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED
             --add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED
             --add-exports=jdk.compiler/com.sun.tools.javac.model=ALL-UNNAMED
@@ -95,6 +94,7 @@
             --add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED
             --add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED
             --add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED
+            --add-opens=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED
             --add-opens=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED
             <!-- The test JVMs are short-running. By disabling certain
             expensive JIT optimizations we actually speed up most tests. -->
@@ -146,13 +146,14 @@
         <version.error-prone>${version.error-prone-orig}</version.error-prone>
         <version.error-prone-fork>v${version.error-prone-orig}-picnic-2</version.error-prone-fork>
         <version.error-prone-orig>2.14.0</version.error-prone-orig>
-        <version.error-prone-slf4j>0.1.15</version.error-prone-slf4j>
+        <version.error-prone-slf4j>0.1.13</version.error-prone-slf4j>
+        <version.findbugs-format-string>3.0.0</version.findbugs-format-string>
         <version.guava-beta-checker>1.0</version.guava-beta-checker>
         <version.jdk>11</version.jdk>
         <version.maven>3.8.6</version.maven>
-        <version.mockito>4.8.0</version.mockito>
+        <version.mockito>4.7.0</version.mockito>
         <version.nopen-checker>1.0.1</version.nopen-checker>
-        <version.nullaway>0.10.0</version.nullaway>
+        <version.nullaway>0.9.9</version.nullaway>
         <!-- XXX: Two other dependencies are potentially of interest:
         `com.palantir.assertj-automation:assertj-refaster-rules` and
         `com.palantir.baseline:baseline-refaster-rules` contain Refaster rules
@@ -215,7 +216,7 @@
             <dependency>
                 <groupId>com.fasterxml.jackson</groupId>
                 <artifactId>jackson-bom</artifactId>
-                <version>2.13.4</version>
+                <version>2.13.3</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -239,11 +240,23 @@
                 <artifactId>auto-value-annotations</artifactId>
                 <version>${version.auto-value}</version>
             </dependency>
+            <!-- Specified as a workaround for
+            https://github.com/mojohaus/versions-maven-plugin/issues/244. -->
+            <dependency>
+                <groupId>com.google.code.findbugs</groupId>
+                <artifactId>jFormatString</artifactId>
+                <version>${version.findbugs-format-string}</version>
+            </dependency>
             <dependency>
                 <groupId>com.google.code.findbugs</groupId>
                 <artifactId>jsr305</artifactId>
                 <version>3.0.2</version>
             </dependency>
+            <dependency>
+                <groupId>com.google.errorprone</groupId>
+                <artifactId>javac</artifactId>
+                <version>9+181-r4173-1</version>
+            </dependency>
             <dependency>
                 <groupId>com.google.googlejavaformat</groupId>
                 <artifactId>google-java-format</artifactId>
@@ -366,7 +379,7 @@
             <dependency>
                 <groupId>org.checkerframework</groupId>
                 <artifactId>checker-qual</artifactId>
-                <version>3.25.0</version>
+                <version>3.24.0</version>
             </dependency>
             <dependency>
                 <groupId>org.hamcrest</groupId>
@@ -376,7 +389,7 @@
             <dependency>
                 <groupId>org.immutables</groupId>
                 <artifactId>value-annotations</artifactId>
-                <version>2.9.2</version>
+                <version>2.9.0</version>
             </dependency>
             <dependency>
                 <groupId>org.junit</groupId>
@@ -392,6 +405,11 @@
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
+            <dependency>
+                <groupId>org.reactivestreams</groupId>
+                <artifactId>reactive-streams</artifactId>
+                <version>1.0.4</version>
+            </dependency>
             <dependency>
                 <groupId>org.slf4j</groupId>
                 <artifactId>slf4j-api</artifactId>
@@ -509,7 +527,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-checkstyle-plugin</artifactId>
-                    <version>3.2.0</version>
+                    <version>3.1.2</version>
                     <configuration>
                         <checkstyleRules>
                             <!-- We only enable rules that are not enforced by
@@ -728,7 +746,6 @@
                                     <module name="VisibilityModifier" />
                                 </module>
                                 <module name="UniqueProperties" />
-                                <module name="io.spring.nohttp.checkstyle.check.NoHttpCheck" />
                             </module>
                         </checkstyleRules>
                         <failOnViolation>false</failOnViolation>
@@ -752,12 +769,7 @@
                         <dependency>
                             <groupId>com.puppycrawl.tools</groupId>
                             <artifactId>checkstyle</artifactId>
-                            <version>10.3.3</version>
-                        </dependency>
-                        <dependency>
-                            <groupId>io.spring.nohttp</groupId>
-                            <artifactId>nohttp-checkstyle</artifactId>
-                            <version>0.0.10</version>
+                            <version>10.3.2</version>
                         </dependency>
                     </dependencies>
                     <executions>
@@ -779,7 +791,7 @@
                     <artifactId>maven-compiler-plugin</artifactId>
                     <version>3.10.1</version>
                     <configuration>
-                        <!-- XXX: MCOMPILER-503: The plugin constructs a highly
+                        <!-- XXX: MCOMPILER-503: The plugin contructs a highly
                         unintuitive annotation processor classpath, in which
                         some indirect dependencies take precedence over
                         explicitly defined dependencies. This can largely be
@@ -839,19 +851,13 @@
                             </path>
                         </annotationProcessorPaths>
                         <compilerArgs>
-                            <arg>--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
-                            <arg>--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
-                            <arg>--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
-                            <arg>--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
-                            <arg>--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
                             <arg>-Xmaxerrs</arg>
                             <arg>10000</arg>
                             <arg>-Xmaxwarns</arg>
                             <arg>10000</arg>
                         </compilerArgs>
                         <parameters>true</parameters>
-                        <source>${version.jdk}</source>
-                        <target>${version.jdk}</target>
+                        <release>${version.jdk}</release>
                         <!-- Erroneously inverted logic... for details, see
                         https://issues.apache.org/jira/browse/MCOMPILER-209. -->
                         <useIncrementalCompilation>false</useIncrementalCompilation>
@@ -1239,7 +1245,7 @@
                 <plugin>
                     <groupId>org.pitest</groupId>
                     <artifactId>pitest-maven</artifactId>
-                    <version>1.9.5</version>
+                    <version>1.9.4</version>
                     <configuration>
                         <!-- Use multiple threads to speed things up. Extend
                         timeouts to prevent false positives as a result of
@@ -1713,6 +1719,41 @@
                 </pluginManagement>
             </build>
         </profile>
+        <profile>
+            <!-- Some code in this project interfaces directly with the Java
+            compiler. The following `add-exports` arguments are not necessary
+            for the code to compile because `com.google.errorprone:javac` is on
+            the classpath. In fact, enabling this profile when building with
+            Maven on the command line will cause a build failure, because these
+            flags are incompatible with the `release` flag. This profile exists
+            solely to be enabled within an IDE: without them IntelliJ IDEA
+            reports compilation errors. -->
+            <id>add-exports</id>
+            <build>
+                <pluginManagement>
+                    <plugins>
+                        <plugin>
+                            <groupId>org.apache.maven.plugins</groupId>
+                            <artifactId>maven-compiler-plugin</artifactId>
+                            <configuration>
+                                <compilerArgs combine.children="append">
+                                    <arg>--add-exports</arg>
+                                    <arg>jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED</arg>
+                                    <arg>--add-exports</arg>
+                                    <arg>jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED</arg>
+                                    <arg>--add-exports</arg>
+                                    <arg>jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED</arg>
+                                    <arg>--add-exports</arg>
+                                    <arg>jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED</arg>
+                                    <arg>--add-exports</arg>
+                                    <arg>jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED</arg>
+                                </compilerArgs>
+                            </configuration>
+                        </plugin>
+                    </plugins>
+                </pluginManagement>
+            </build>
+        </profile>
         <profile>
             <!-- This profile is auto-activated when performing a release. -->
             <id>release</id>

refaster-compiler/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.1.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-compiler</artifactId>
@@ -37,6 +37,11 @@
             <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

refaster-runner/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.1.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-runner</artifactId>
@@ -47,6 +47,11 @@
             <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

refaster-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.1.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-support</artifactId>
@@ -51,6 +51,11 @@
             <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>

refaster-test-support/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>tech.picnic.error-prone-support</groupId>
         <artifactId>error-prone-support</artifactId>
-        <version>0.2.1-SNAPSHOT</version>
+        <version>0.1.1-SNAPSHOT</version>
     </parent>
 
     <artifactId>refaster-test-support</artifactId>
@@ -50,6 +50,11 @@
             <artifactId>jsr305</artifactId>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.errorprone</groupId>
+            <artifactId>javac</artifactId>
+            <scope>provided</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>

refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/ValidTemplates.java

@@ -7,6 +7,7 @@ import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
 import com.google.errorprone.refaster.annotation.Placeholder;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
+import java.util.Objects;
 import java.util.Set;
 import javax.annotation.Nullable;
 
@@ -29,7 +30,7 @@ final class ValidTemplates {
   static final class StaticImportStringLength {
     @BeforeTemplate
     boolean before(@Nullable String string) {
-      return string == null || string.toCharArray().length == 0;
+      return Objects.isNull(string) || string.isEmpty();
     }
 
     @AfterTemplate

refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidTemplatesTestInput.java

@@ -3,13 +3,14 @@ package tech.picnic.errorprone.refaster.test;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableSet;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 
 /** Code to test the Refaster templates from {@link ValidTemplates}. */
 final class ValidTemplatesTest implements RefasterTemplateTestCase {
   @Override
   public ImmutableSet<?> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Strings.class);
+    return ImmutableSet.of(Objects.class, Strings.class);
   }
 
   boolean testStringIsEmpty2() {
@@ -17,7 +18,7 @@ final class ValidTemplatesTest implements RefasterTemplateTestCase {
   }
 
   boolean testStaticImportStringLength() {
-    return "foo" == null || "foo".toCharArray().length == 0;
+    return Objects.isNull("foo") || "foo".isEmpty();
   }
 
   void testBlockTemplateSetAddElement() {

refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/ValidTemplatesTestOutput.java

@@ -5,13 +5,14 @@ import static com.google.common.base.Strings.isNullOrEmpty;
 import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableSet;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.Set;
 
 /** Code to test the Refaster templates from {@link ValidTemplates}. */
 final class ValidTemplatesTest implements RefasterTemplateTestCase {
   @Override
   public ImmutableSet<?> elidedTypesAndStaticImports() {
-    return ImmutableSet.of(Strings.class);
+    return ImmutableSet.of(Objects.class, Strings.class);
   }
 
   boolean testStringIsEmpty2() {