Apply assorted non-functional improvements (#2054)

Summary of changes:
- Improve the intentionality of some code in `AssertJNullnessAssertion`.
- Document a possible improvement of `ExplicitArgumentEnumeration`.
- Add class documentation to several `AssertJ*Rules` classes.
- Update the Checkstyle configuration to better match the 
  Picnic-internal codebase.
- Simplify the Surefire system properties configuration.

Author: Stephan202

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

@@ -12,6 +12,7 @@
 
 import com.google.auto.service.AutoService;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Sets;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.VisitorState;
@@ -65,11 +66,12 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState
     }
 
     String replacementAssertion = isPositiveAssertion(tree) ? "isNull" : "isNotNull";
-    SuggestedFix.Builder fix =
-        SuggestedFixes.renameMethodInvocation(tree, replacementAssertion, state).toBuilder();
-    tree.getArguments().forEach(arg -> fix.merge(SuggestedFix.delete(arg)));
+    SuggestedFix fix =
+        SuggestedFixes.renameMethodInvocation(tree, replacementAssertion, state).toBuilder()
+            .merge(SuggestedFix.delete(Iterables.getOnlyElement(tree.getArguments())))
+            .build();
 
-    return describeMatch(tree, fix.build());
+    return describeMatch(tree, fix);
   }
 
   private static boolean isPositiveAssertion(MethodInvocationTree tree) {

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

@@ -64,6 +64,8 @@
 // XXX: Besides explicitly enumerated iterables, consider also simplifying expressions that contain
 // explicitly enumerated `Stream`s, defined using `Stream.of(...)` or `() -> Stream.of(...)`. This
 // would allow simplifying e.g. invocations of `Flux#fromStream` to `Flux#just`.
+// XXX: Consider also rewrites in the opposite direction, where `overload(collection.toArray(..))`
+// can be simplified to `overload(collection)`, provided that a suitable overload exists.
 @AutoService(BugChecker.class)
 @BugPattern(
     summary = "Iterable creation can be avoided by using a varargs alternative method",

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

@@ -10,6 +10,7 @@
 import org.assertj.core.api.AbstractBigIntegerAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@link BigInteger}s. */
 // XXX: If we add a rule that drops unnecessary `L` suffixes from literal longs, then the `0L`/`1L`
 // cases below can go.
 @OnlineDocumentation

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

@@ -10,6 +10,7 @@
 import org.assertj.core.api.AbstractBooleanAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@code boolean}s. */
 @OnlineDocumentation
 final class AssertJBooleanRules {
   private AssertJBooleanRules() {}

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

@@ -9,6 +9,7 @@
 import org.assertj.core.api.AbstractByteAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@code byte}s. */
 @OnlineDocumentation
 final class AssertJByteRules {
   private AssertJByteRules() {}

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

@@ -10,6 +10,7 @@
 import org.assertj.core.api.AbstractAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@link CharSequence}s. */
 @OnlineDocumentation
 final class AssertJCharSequenceRules {
   private AssertJCharSequenceRules() {}

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

@@ -10,6 +10,7 @@
 import org.assertj.core.api.AbstractIntegerAssert;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@link Comparable}s. */
 @OnlineDocumentation
 final class AssertJComparableRules {
   private AssertJComparableRules() {}

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

@@ -10,6 +10,7 @@
 import org.assertj.core.data.Offset;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@code double}s. */
 @OnlineDocumentation
 final class AssertJDoubleRules {
   private AssertJDoubleRules() {}

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

@@ -15,6 +15,7 @@
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 import tech.picnic.errorprone.refaster.matchers.IsEmpty;
 
+/** Refaster rules related to AssertJ assertions over enumerable objects. */
 @OnlineDocumentation
 final class AssertJEnumerableRules {
   private AssertJEnumerableRules() {}

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

@@ -10,6 +10,7 @@
 import org.assertj.core.data.Offset;
 import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
 
+/** Refaster rules related to AssertJ assertions over {@code float}s. */
 @OnlineDocumentation
 final class AssertJFloatRules {
   private AssertJFloatRules() {}