Upgrade Error Prone 2.10.0 -> 2.14.0 and errorprone-slf4j 0.1.4 -> 0.1.12

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

@@ -8,6 +8,7 @@
 import static com.google.errorprone.matchers.Matchers.isType;
 
 import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
@@ -43,7 +44,7 @@ public Description matchClass(ClassTree tree, VisitorState state) {
       return Description.NO_MATCH;
     }
 
-    List<AnnotationTree> annotations =
+    ImmutableList<AnnotationTree> annotations =
         AUTOWIRED_ANNOTATION
             .multiMatchResult(Iterables.getOnlyElement(constructors), state)
             .matchingNodes();

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

@@ -31,6 +31,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
+import javax.annotation.Nullable;
 
 /**
  * A {@link BugChecker} which flags string concatenations that produce a format string; in such
@@ -210,6 +211,7 @@ private static class ReplacementArgumentsConstructor
       this.formatSpecifier = formatSpecifier;
     }
 
+    @Nullable
     @Override
     public Void visitBinary(BinaryTree tree, VisitorState state) {
       if (tree.getKind() == Kind.PLUS && isStringTyped(tree, state)) {
@@ -222,11 +224,13 @@ public Void visitBinary(BinaryTree tree, VisitorState state) {
       return null;
     }
 
+    @Nullable
     @Override
     public Void visitParenthesized(ParenthesizedTree tree, VisitorState state) {
       return tree.getExpression().accept(this, state);
     }
 
+    @Nullable
     @Override
     protected Void defaultAction(Tree tree, VisitorState state) {
       appendExpression(tree);

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

@@ -37,6 +37,7 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
+import javax.annotation.Nullable;
 
 /**
  * A {@link BugChecker} which flags annotation array listings which aren't sorted lexicographically.
@@ -171,18 +172,21 @@ private static ImmutableList<ImmutableList<String>> getStructure(
     ImmutableList.Builder<ImmutableList<String>> nodes = ImmutableList.builder();
 
     new TreeScanner<Void, Void>() {
+      @Nullable
       @Override
       public Void visitIdentifier(IdentifierTree node, Void ctx) {
         nodes.add(tokenize(node));
         return super.visitIdentifier(node, ctx);
       }
 
+      @Nullable
       @Override
       public Void visitLiteral(LiteralTree node, Void ctx) {
         nodes.add(tokenize(node));
         return super.visitLiteral(node, ctx);
       }
 
+      @Nullable
       @Override
       public Void visitPrimitiveType(PrimitiveTypeTree node, Void ctx) {
         nodes.add(tokenize(node));

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

@@ -166,11 +166,12 @@ private static CodeTransformer createCompositeCodeTransformer(ErrorProneFlags fl
         flags
             .get(INCLUDED_TEMPLATES_PATTERN_FLAG)
             .map(Pattern::compile)
-            .map(nameFilter -> filterCodeTransformers(allTransformers, nameFilter))
+            .<ImmutableCollection<CodeTransformer>>map(
+                nameFilter -> filterCodeTransformers(allTransformers, nameFilter))
             .orElseGet(allTransformers::values));
   }
 
-  private static ImmutableCollection<CodeTransformer> filterCodeTransformers(
+  private static ImmutableList<CodeTransformer> filterCodeTransformers(
       ImmutableListMultimap<String, CodeTransformer> transformers, Pattern nameFilter) {
     return transformers.entries().stream()
         .filter(e -> nameFilter.matcher(e.getKey()).matches())

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

@@ -75,7 +75,7 @@ public Description matchMethod(MethodTree tree, VisitorState state) {
     return describeMatch(
         traceAnnotation,
         SuggestedFixes.updateAnnotationArgumentValues(
-                traceAnnotation, "dispatcher", ImmutableList.of("true"))
+                traceAnnotation, state, "dispatcher", ImmutableList.of("true"))
             .build());
   }
 

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

@@ -59,7 +59,7 @@ public final class TimeZoneUsageCheck extends BugChecker implements MethodInvoca
                   LocalDateTime.class.getName(),
                   LocalTime.class.getName())
               .named("now"),
-          staticMethod().onClassAny(Instant.class.getName()).named("now").withParameters());
+          staticMethod().onClassAny(Instant.class.getName()).named("now").withNoParameters());
 
   @Override
   public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {

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

@@ -268,9 +268,9 @@ static final class AssertThatThrownByIOException {
   }
 
   static final class AssertThatThrownByIOExceptionHasMessage {
+    @BeforeTemplate
     @SuppressWarnings(
         "AssertThatThrownByIOException" /* Matches strictly more specific expressions. */)
-    @BeforeTemplate
     AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message) {
       return assertThatIOException().isThrownBy(throwingCallable).withMessage(message);
     }

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

@@ -92,7 +92,7 @@ ImmutableListMultimap<K, V> after(K key, V value) {
    */
   static final class EntryToImmutableListMultimap<K, V> {
     @BeforeTemplate
-    ImmutableMultimap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
+    ImmutableListMultimap<K, V> before(Map.Entry<? extends K, ? extends V> entry) {
       return Refaster.anyOf(
           ImmutableListMultimap.<K, V>builder().put(entry).build(),
           Stream.of(entry)

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

@@ -4,7 +4,6 @@
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 
-import com.google.common.collect.ImmutableMultiset;
 import com.google.common.collect.ImmutableSortedMultiset;
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -91,22 +90,22 @@ ImmutableSortedMultiset<T> after() {
   // `reverseOrder`.) Worth the hassle?
   static final class IterableToImmutableSortedMultiset<T extends Comparable<? super T>> {
     @BeforeTemplate
-    ImmutableMultiset<T> before(T[] iterable) {
+    ImmutableSortedMultiset<T> before(T[] iterable) {
       return Refaster.anyOf(
           ImmutableSortedMultiset.<T>naturalOrder().add(iterable).build(),
           Arrays.stream(iterable).collect(toImmutableSortedMultiset(naturalOrder())));
     }
 
     @BeforeTemplate
-    ImmutableMultiset<T> before(Iterator<T> iterable) {
+    ImmutableSortedMultiset<T> before(Iterator<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedMultiset.copyOf(naturalOrder(), iterable),
           ImmutableSortedMultiset.<T>naturalOrder().addAll(iterable).build(),
           Streams.stream(iterable).collect(toImmutableSortedMultiset(naturalOrder())));
     }
 
     @BeforeTemplate
-    ImmutableMultiset<T> before(Iterable<T> iterable) {
+    ImmutableSortedMultiset<T> before(Iterable<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedMultiset.copyOf(naturalOrder(), iterable),
           ImmutableSortedMultiset.<T>naturalOrder().addAll(iterable).build(),

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

@@ -4,7 +4,6 @@
 import static com.google.errorprone.refaster.ImportPolicy.STATIC_IMPORT_ALWAYS;
 import static java.util.Comparator.naturalOrder;
 
-import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Streams;
 import com.google.errorprone.refaster.Refaster;
@@ -89,22 +88,22 @@ ImmutableSortedSet<T> after() {
   // `reverseOrder`.) Worth the hassle?
   static final class IterableToImmutableSortedSet<T extends Comparable<? super T>> {
     @BeforeTemplate
-    ImmutableSet<T> before(T[] iterable) {
+    ImmutableSortedSet<T> before(T[] iterable) {
       return Refaster.anyOf(
           ImmutableSortedSet.<T>naturalOrder().add(iterable).build(),
           Arrays.stream(iterable).collect(toImmutableSortedSet(naturalOrder())));
     }
 
     @BeforeTemplate
-    ImmutableSet<T> before(Iterator<T> iterable) {
+    ImmutableSortedSet<T> before(Iterator<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedSet.copyOf(naturalOrder(), iterable),
           ImmutableSortedSet.<T>naturalOrder().addAll(iterable).build(),
           Streams.stream(iterable).collect(toImmutableSortedSet(naturalOrder())));
     }
 
     @BeforeTemplate
-    ImmutableSet<T> before(Iterable<T> iterable) {
+    ImmutableSortedSet<T> before(Iterable<T> iterable) {
       return Refaster.anyOf(
           ImmutableSortedSet.copyOf(naturalOrder(), iterable),
           ImmutableSortedSet.<T>naturalOrder().addAll(iterable).build(),

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

@@ -4,8 +4,6 @@
 import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
 import com.google.errorprone.CompilationTestHelper;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.DisabledForJreRange;
-import org.junit.jupiter.api.condition.JRE;
 
 final class ScheduledTransactionTraceCheckTest {
   private final CompilationTestHelper compilationTestHelper =
@@ -45,10 +43,7 @@ void identification() {
         .doTest();
   }
 
-  // XXX: Enable this test for all JREs once https://github.com/google/error-prone/pull/2820 is
-  // merged and released.
   @Test
-  @DisabledForJreRange(min = JRE.JAVA_12)
   void replacement() {
     refactoringTestHelper
         .addInputLines(

pom.xml

@@ -134,9 +134,9 @@
         <version.auto-service>1.0.1</version.auto-service>
         <version.auto-value>1.9</version.auto-value>
         <version.error-prone>${version.error-prone-orig}</version.error-prone>
-        <version.error-prone-fork>v${version.error-prone-orig}-picnic-3</version.error-prone-fork>
-        <version.error-prone-orig>2.10.0</version.error-prone-orig>
-        <version.error-prone-slf4j>0.1.4</version.error-prone-slf4j>
+        <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.12</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>
@@ -348,6 +348,11 @@
                 <artifactId>checker-qual</artifactId>
                 <version>3.23.0</version>
             </dependency>
+            <dependency>
+                <groupId>org.hamcrest</groupId>
+                <artifactId>hamcrest-core</artifactId>
+                <version>2.2</version>
+            </dependency>
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
@@ -1264,7 +1269,7 @@
                 `BugChecker` test code and the Refaster test files) does not
                 exhibit anti-patterns other than those associated with the
                 check/template under test. Ideally all test cases are realistic. -->
-                <error-prone.self-check-args>-Xep:MethodReferenceUsage:OFF</error-prone.self-check-args>
+                <error-prone.self-check-args>-XepAllSuggestionsAsWarnings -Xep:MethodReferenceUsage:OFF</error-prone.self-check-args>
             </properties>
             <build>
                 <plugins>
@@ -1492,18 +1497,28 @@
                                     <!-- XXX: Enable this once we open-source
                                     this library. -->
                                     -Xep:BetaApi:OFF
+                                    <!-- XXX: Enable this check. -->
+                                    -Xep:BugPatternNaming:OFF
                                     <!-- We don't target JDK 7. -->
                                     -Xep:Java7ApiChecker:OFF
                                     <!-- We don't target JDK 8. -->
                                     -Xep:Java8ApiChecker:OFF
                                     <!-- We don't target Android. -->
                                     -Xep:StaticOrDefaultInterfaceMethod:OFF
+                                    <!-- We generally discourage `var` use. -->
+                                    -Xep:Varifier:OFF
                                     <!-- XXX: This check flags false positives.
                                     See https://github.com/google/error-prone/issues/2679. -->
                                     -Xep:VoidMissingNullable:OFF
+                                    -XepOpt:CheckReturnValue:CheckAllConstructors=true
+                                    <!-- XXX: Enable once there are fewer
+                                    false-positives.
+                                    -XepOpt:CheckReturnValue:CheckAllMethods=true -->
+                                    -XepOpt:InlineMe:SkipInliningsWithComments=false
                                     -XepOpt:NullAway:AnnotatedPackages=tech.picnic
                                     -XepOpt:NullAway:AssertsEnabled=true
                                     -XepOpt:NullAway:CheckOptionalEmptiness=true
+                                    -XepOpt:Nullness:Conservative=false
                                     <!-- Append additional custom arguments. -->
                                     ${error-prone.patch-args}
                                     ${error-prone.self-check-args}

refaster-compiler/src/main/java/tech/picnic/errorprone/refaster/plugin/RefasterRuleCompilerTaskListener.java

@@ -29,6 +29,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import javax.annotation.Nullable;
 import javax.tools.FileObject;
 import javax.tools.JavaFileManager;
 import javax.tools.StandardLocation;
@@ -91,6 +92,7 @@ private ImmutableListMultimap<ClassTree, CodeTransformer> compileRefasterTemplat
       ClassTree tree) {
     ListMultimap<ClassTree, CodeTransformer> rules = ArrayListMultimap.create();
     new TreeScanner<Void, Void>() {
+      @Nullable
       @Override
       public Void visitClass(ClassTree node, Void v) {
         rules.putAll(node, RefasterRuleBuilderScanner.extractRules(node, context));