Upgrade Error Prone 2.38.0 -> 2.39.0 (#1741)

Picnic-DevPla-Bot · web-flow · commit aa061ed206d8 · 2025-07-03T10:20:05.000+02:00
See: - https://github.com/google/error-prone/releases/tag/v2.39.0 - google/error-prone@v2.38.0...v2.39.0
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/StaticImport.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/StaticImport.java
@@ -42,10 +42,10 @@
 import com.google.errorprone.predicates.TypePredicates;
 import com.google.errorprone.refaster.ImportPolicy;
 import com.google.errorprone.util.ASTHelpers;
+import com.sun.source.tree.ImportTree;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.Tree;
-import com.sun.source.tree.Tree.Kind;
 import com.sun.tools.javac.code.Type;
 import java.nio.charset.StandardCharsets;
 import java.time.ZoneOffset;
@@ -215,7 +215,7 @@ private static boolean isCandidateContext(VisitorState state) {
 
     return parentTree instanceof MethodInvocationTree methodInvocation
         ? methodInvocation.getTypeArguments().isEmpty()
-        : (parentTree.getKind() != Kind.IMPORT && parentTree.getKind() != Kind.MEMBER_SELECT);
+        : !(parentTree instanceof ImportTree || parentTree instanceof MemberSelectTree);
   }
 
   private static boolean isCandidate(MemberSelectTree tree) {
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJBooleanRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/AssertJBooleanRules.java
@@ -41,11 +41,7 @@ AbstractBooleanAssert<?> after(AbstractBooleanAssert<?> boolAssert, boolean othe
   static final class AbstractBooleanAssertIsTrue {
     @BeforeTemplate
     AbstractBooleanAssert<?> before(AbstractBooleanAssert<?> boolAssert) {
-      return Refaster.anyOf(
-          boolAssert.isEqualTo(true),
-          boolAssert.isEqualTo(Boolean.TRUE),
-          boolAssert.isNotEqualTo(false),
-          boolAssert.isNotEqualTo(Boolean.FALSE));
+      return Refaster.anyOf(boolAssert.isEqualTo(true), boolAssert.isNotEqualTo(false));
     }
 
     @AfterTemplate
@@ -70,11 +66,7 @@ AbstractBooleanAssert<?> after(boolean b) {
   static final class AbstractBooleanAssertIsFalse {
     @BeforeTemplate
     AbstractBooleanAssert<?> before(AbstractBooleanAssert<?> boolAssert) {
-      return Refaster.anyOf(
-          boolAssert.isEqualTo(false),
-          boolAssert.isEqualTo(Boolean.FALSE),
-          boolAssert.isNotEqualTo(true),
-          boolAssert.isNotEqualTo(Boolean.TRUE));
+      return Refaster.anyOf(boolAssert.isEqualTo(false), boolAssert.isNotEqualTo(true));
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refasterrules/OptionalRules.java
@@ -190,9 +190,8 @@ Optional<T> after(T input) {
    */
   static final class MapOptionalToBoolean<T> {
     @BeforeTemplate
-    @SuppressWarnings("OptionalOrElseGet" /* Rule is confused by `Refaster#anyOf` usage. */)
     boolean before(Optional<T> optional, Function<? super T, Boolean> predicate) {
-      return optional.map(predicate).orElse(Refaster.anyOf(false, Boolean.FALSE));
+      return optional.map(predicate).orElse(false);
     }
 
     @AfterTemplate
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBooleanRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBooleanRulesTestInput.java
@@ -16,23 +16,15 @@ AbstractBooleanAssert<?> testAbstractBooleanAssertIsNotEqualTo() {
   }
 
   ImmutableSet<AbstractBooleanAssert<?>> testAbstractBooleanAssertIsTrue() {
-    return ImmutableSet.of(
-        assertThat(true).isEqualTo(true),
-        assertThat(true).isEqualTo(Boolean.TRUE),
-        assertThat(true).isNotEqualTo(false),
-        assertThat(true).isNotEqualTo(Boolean.FALSE));
+    return ImmutableSet.of(assertThat(true).isEqualTo(true), assertThat(true).isNotEqualTo(false));
   }
 
   AbstractBooleanAssert<?> testAssertThatBooleanIsTrue() {
     return assertThat(!Boolean.TRUE).isFalse();
   }
 
   ImmutableSet<AbstractBooleanAssert<?>> testAbstractBooleanAssertIsFalse() {
-    return ImmutableSet.of(
-        assertThat(true).isEqualTo(false),
-        assertThat(true).isEqualTo(Boolean.FALSE),
-        assertThat(true).isNotEqualTo(true),
-        assertThat(true).isNotEqualTo(Boolean.TRUE));
+    return ImmutableSet.of(assertThat(true).isEqualTo(false), assertThat(true).isNotEqualTo(true));
   }
 
   AbstractBooleanAssert<?> testAssertThatBooleanIsFalse() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBooleanRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/AssertJBooleanRulesTestOutput.java
@@ -16,23 +16,15 @@ AbstractBooleanAssert<?> testAbstractBooleanAssertIsNotEqualTo() {
   }
 
   ImmutableSet<AbstractBooleanAssert<?>> testAbstractBooleanAssertIsTrue() {
-    return ImmutableSet.of(
-        assertThat(true).isTrue(),
-        assertThat(true).isTrue(),
-        assertThat(true).isTrue(),
-        assertThat(true).isTrue());
+    return ImmutableSet.of(assertThat(true).isTrue(), assertThat(true).isTrue());
   }
 
   AbstractBooleanAssert<?> testAssertThatBooleanIsTrue() {
     return assertThat(Boolean.TRUE).isTrue();
   }
 
   ImmutableSet<AbstractBooleanAssert<?>> testAbstractBooleanAssertIsFalse() {
-    return ImmutableSet.of(
-        assertThat(true).isFalse(),
-        assertThat(true).isFalse(),
-        assertThat(true).isFalse(),
-        assertThat(true).isFalse());
+    return ImmutableSet.of(assertThat(true).isFalse(), assertThat(true).isFalse());
   }
 
   AbstractBooleanAssert<?> testAssertThatBooleanIsFalse() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestInput.java
@@ -63,10 +63,8 @@ Optional<String> testTernaryOperatorOptionalNegativeFiltering() {
     return "foo".length() > 5 ? Optional.empty() : Optional.of("foo");
   }
 
-  ImmutableSet<Boolean> testMapOptionalToBoolean() {
-    return ImmutableSet.of(
-        Optional.of("foo").map(String::isEmpty).orElse(false),
-        Optional.of("bar").map(s -> s.isEmpty()).orElse(Boolean.FALSE));
+  boolean testMapOptionalToBoolean() {
+    return Optional.of("foo").map(String::isEmpty).orElse(false);
   }
 
   ImmutableSet<Optional<String>> testMapToNullable() {
diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/refasterrules/OptionalRulesTestOutput.java
@@ -61,10 +61,8 @@ Optional<String> testTernaryOperatorOptionalNegativeFiltering() {
         .filter(v -> v.length() <= 5);
   }
 
-  ImmutableSet<Boolean> testMapOptionalToBoolean() {
-    return ImmutableSet.of(
-        Optional.of("foo").filter(String::isEmpty).isPresent(),
-        Optional.of("bar").filter(s -> s.isEmpty()).isPresent());
+  boolean testMapOptionalToBoolean() {
+    return Optional.of("foo").filter(String::isEmpty).isPresent();
   }
 
   ImmutableSet<Optional<String>> testMapToNullable() {
diff --git a/error-prone-utils/src/main/java/tech/picnic/errorprone/utils/ConflictDetection.java b/error-prone-utils/src/main/java/tech/picnic/errorprone/utils/ConflictDetection.java
@@ -74,7 +74,7 @@ public Boolean visitClass(ClassTree tree, @Nullable Void unused) {
                * Don't descend into static type definitions: in those context, any unqualified
                * method invocation cannot refer to a method in the outer scope.
                */
-              return Boolean.FALSE;
+              return false;
             }
 
             return super.visitClass(tree, null);
diff --git a/error-prone-utils/src/main/java/tech/picnic/errorprone/utils/ThirdPartyLibrary.java b/error-prone-utils/src/main/java/tech/picnic/errorprone/utils/ThirdPartyLibrary.java
@@ -124,6 +124,6 @@ private static boolean shouldIgnoreClasspath(VisitorState state) {
         .errorProneOptions()
         .getFlags()
         .getBoolean(IGNORE_CLASSPATH_COMPAT_FLAG)
-        .orElse(Boolean.FALSE);
+        .orElse(false);
   }
 }
diff --git a/pom.xml b/pom.xml
@@ -206,7 +206,7 @@
         <version.auto-value>1.11.0</version.auto-value>
         <version.error-prone>${version.error-prone-orig}</version.error-prone>
         <version.error-prone-fork>${version.error-prone-orig}-picnic-1</version.error-prone-fork>
-        <version.error-prone-orig>2.38.0</version.error-prone-orig>
+        <version.error-prone-orig>2.39.0</version.error-prone-orig>
         <version.jdk>17</version.jdk>
         <version.maven>3.9.10</version.maven>
         <version.pitest-git>2.2.3</version.pitest-git>

Original file line number	Diff line number	Diff line change
`@@ -16,23 +16,15 @@ AbstractBooleanAssert<?> testAbstractBooleanAssertIsNotEqualTo() {`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`ImmutableSet<AbstractBooleanAssert<?>> testAbstractBooleanAssertIsTrue() {`
`19`		`- return ImmutableSet.of(`
`20`		`- assertThat(true).isEqualTo(true),`
`21`		`- assertThat(true).isEqualTo(Boolean.TRUE),`
`22`		`- assertThat(true).isNotEqualTo(false),`
`23`		`- assertThat(true).isNotEqualTo(Boolean.FALSE));`
	`19`	`+ return ImmutableSet.of(assertThat(true).isEqualTo(true), assertThat(true).isNotEqualTo(false));`
`24`	`20`	`}`
`25`	`21`
`26`	`22`	`AbstractBooleanAssert<?> testAssertThatBooleanIsTrue() {`
`27`	`23`	`return assertThat(!Boolean.TRUE).isFalse();`
`28`	`24`	`}`
`29`	`25`
`30`	`26`	`ImmutableSet<AbstractBooleanAssert<?>> testAbstractBooleanAssertIsFalse() {`
`31`		`- return ImmutableSet.of(`
`32`		`- assertThat(true).isEqualTo(false),`
`33`		`- assertThat(true).isEqualTo(Boolean.FALSE),`
`34`		`- assertThat(true).isNotEqualTo(true),`
`35`		`- assertThat(true).isNotEqualTo(Boolean.TRUE));`
	`27`	`+ return ImmutableSet.of(assertThat(true).isEqualTo(false), assertThat(true).isNotEqualTo(true));`
`36`	`28`	`}`
`37`	`29`
`38`	`30`	`AbstractBooleanAssert<?> testAssertThatBooleanIsFalse() {`
Original file line number	Diff line number	Diff line change
`@@ -63,10 +63,8 @@ Optional<String> testTernaryOperatorOptionalNegativeFiltering() {`
`63`	`63`	`return "foo".length() > 5 ? Optional.empty() : Optional.of("foo");`
`64`	`64`	`}`
`65`	`65`
`66`		`- ImmutableSet<Boolean> testMapOptionalToBoolean() {`
`67`		`- return ImmutableSet.of(`
`68`		`- Optional.of("foo").map(String::isEmpty).orElse(false),`
`69`		`- Optional.of("bar").map(s -> s.isEmpty()).orElse(Boolean.FALSE));`
	`66`	`+ boolean testMapOptionalToBoolean() {`
	`67`	`+ return Optional.of("foo").map(String::isEmpty).orElse(false);`
`70`	`68`	`}`
`71`	`69`
`72`	`70`	`ImmutableSet<Optional<String>> testMapToNullable() {`
Original file line number	Diff line number	Diff line change
`@@ -61,10 +61,8 @@ Optional<String> testTernaryOperatorOptionalNegativeFiltering() {`
`61`	`61`	`.filter(v -> v.length() <= 5);`
`62`	`62`	`}`
`63`	`63`
`64`		`- ImmutableSet<Boolean> testMapOptionalToBoolean() {`
`65`		`- return ImmutableSet.of(`
`66`		`- Optional.of("foo").filter(String::isEmpty).isPresent(),`
`67`		`- Optional.of("bar").filter(s -> s.isEmpty()).isPresent());`
	`64`	`+ boolean testMapOptionalToBoolean() {`
	`65`	`+ return Optional.of("foo").filter(String::isEmpty).isPresent();`
`68`	`66`	`}`
`69`	`67`
`70`	`68`	`ImmutableSet<Optional<String>> testMapToNullable() {`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ public Boolean visitClass(ClassTree tree, @Nullable Void unused) {`
`74`	`74`	`* Don't descend into static type definitions: in those context, any unqualified`
`75`	`75`	`* method invocation cannot refer to a method in the outer scope.`
`76`	`76`	`*/`
`77`		`- return Boolean.FALSE;`
	`77`	`+ return false;`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`return super.visitClass(tree, null);`
Original file line number	Diff line number	Diff line change
`@@ -124,6 +124,6 @@ private static boolean shouldIgnoreClasspath(VisitorState state) {`
`124`	`124`	`.errorProneOptions()`
`125`	`125`	`.getFlags()`
`126`	`126`	`.getBoolean(IGNORE_CLASSPATH_COMPAT_FLAG)`
`127`		`- .orElse(Boolean.FALSE);`
	`127`	`+ .orElse(false);`
`128`	`128`	`}`
`129`	`129`	`}`