Introduce StringFormat Refaster rule

XXX: Requires dropping JDK 11 support, or a means of filtering by target
language level.

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

@@ -0,0 +1,33 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.AlsoNegation;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/** Refaster rules related to expressions dealing with {@link CharSequence}s. */
+@OnlineDocumentation
+final class CharSequenceRules {
+  private CharSequenceRules() {}
+
+  /**
+   * Prefer {@link CharSequence#isEmpty()} over alternatives that consult the char sequence's
+   * length.
+   */
+  // XXX: Drop this rule once we (and OpenRewrite) no longer support projects targeting Java 14 or
+  // below.
+  static final class CharSequenceIsEmpty {
+    @BeforeTemplate
+    boolean before(CharSequence charSequence) {
+      return Refaster.anyOf(
+          charSequence.length() == 0, charSequence.length() <= 0, charSequence.length() < 1);
+    }
+
+    @AfterTemplate
+    @AlsoNegation
+    boolean after(CharSequence charSequence) {
+      return charSequence.isEmpty();
+    }
+  }
+}

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

@@ -36,8 +36,7 @@ final class ImmutableListMultimapRules {
    * Prefer {@link ImmutableListMultimap#builder()} over the associated constructor on constructions
    * that produce a less-specific type.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableListMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMultimap.Builder<K, V> before() {

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

@@ -28,8 +28,7 @@ final class ImmutableListRules {
   private ImmutableListRules() {}
 
   /** Prefer {@link ImmutableList#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableListBuilder<T> {
     @BeforeTemplate
     ImmutableList.Builder<T> before() {

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

@@ -31,8 +31,7 @@ final class ImmutableMapRules {
   private ImmutableMapRules() {}
 
   /** Prefer {@link ImmutableMap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableMapBuilder<K, V> {
     @BeforeTemplate
     ImmutableMap.Builder<K, V> before() {

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

@@ -21,8 +21,7 @@ final class ImmutableMultisetRules {
   private ImmutableMultisetRules() {}
 
   /** Prefer {@link ImmutableMultiset#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableMultisetBuilder<T> {
     @BeforeTemplate
     ImmutableMultiset.Builder<T> before() {

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

@@ -29,8 +29,7 @@ final class ImmutableSetMultimapRules {
   private ImmutableSetMultimapRules() {}
 
   /** Prefer {@link ImmutableSetMultimap#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSetMultimapBuilder<K, V> {
     @BeforeTemplate
     ImmutableSetMultimap.Builder<K, V> before() {

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

@@ -29,8 +29,7 @@ final class ImmutableSetRules {
   private ImmutableSetRules() {}
 
   /** Prefer {@link ImmutableSet#builder()} over the associated constructor. */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSetBuilder<T> {
     @BeforeTemplate
     ImmutableSet.Builder<T> before() {

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

@@ -37,8 +37,7 @@ final class ImmutableSortedMapRules {
    * Prefer {@link ImmutableSortedMap#naturalOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSortedMapNaturalOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {
@@ -55,8 +54,7 @@ final class ImmutableSortedMapRules {
    * Prefer {@link ImmutableSortedMap#reverseOrder()} over the alternative that requires explicitly
    * providing the {@link Comparator}.
    */
-  // XXX: This drops generic type information, sometimes leading to non-compilable code. See
-  // https://github.com/google/error-prone/pull/2706.
+  // XXX: This rule may drop generic type information, leading to non-compilable code.
   static final class ImmutableSortedMapReverseOrderBuilder<K extends Comparable<? super K>, V> {
     @BeforeTemplate
     ImmutableSortedMap.Builder<K, V> before() {

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

@@ -9,10 +9,12 @@ import com.google.common.base.Joiner;
 import com.google.common.base.Strings;
 import com.google.common.base.Utf8;
 import com.google.common.collect.Streams;
+import com.google.errorprone.annotations.FormatMethod;
 import com.google.errorprone.refaster.Refaster;
 import com.google.errorprone.refaster.annotation.AfterTemplate;
 import com.google.errorprone.refaster.annotation.AlsoNegation;
 import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import com.google.errorprone.refaster.annotation.Repeated;
 import com.google.errorprone.refaster.annotation.UseImportPolicy;
 import java.util.Arrays;
 import java.util.Collection;
@@ -29,11 +31,14 @@ final class StringRules {
   private StringRules() {}
 
   /** Prefer {@link String#isEmpty()} over alternatives that consult the string's length. */
-  // XXX: Now that we build with JDK 15+, this rule can be generalized to cover all `CharSequence`
-  // subtypes. This does require a mechanism (perhaps an annotation, or a separate Maven module) to
-  // make sure that non-String expressions are rewritten only if client code also targets JDK 15+.
+  // XXX: Drop this rule once we (and OpenRewrite) no longer support projects targeting Java 14 or
+  // below. The `CharSequenceIsEmpty` rule then suffices. (This rule exists so that e.g. projects
+  // that target JDK 11 can disable `CharSequenceIsEmpty` without losing a valuable rule.)
+  // XXX: Look into a more general approach to supporting different Java language levels, such as
+  // rule selection based on some annotation, or a separate Maven module.
   static final class StringIsEmpty {
     @BeforeTemplate
+    @SuppressWarnings("CharSequenceIsEmpty" /* This is a more specific template. */)
     boolean before(String str) {
       return Refaster.anyOf(str.length() == 0, str.length() <= 0, str.length() < 1);
     }
@@ -345,4 +350,23 @@ final class StringRules {
       return string.startsWith(prefix, fromIndex);
     }
   }
+
+  /**
+   * Prefer {@link String#formatted(Object...)} over {@link String#format(String, Object...)}, as
+   * the former works more nicely with text blocks, while the latter does not appear advantageous in
+   * any circumstance (assuming one targets JDK 15+).
+   */
+  static final class StringFormatted {
+    @BeforeTemplate
+    @FormatMethod
+    String before(String format, @Repeated Object args) {
+      return String.format(format, args);
+    }
+
+    @AfterTemplate
+    @FormatMethod
+    String after(String format, @Repeated Object args) {
+      return format.formatted(args);
+    }
+  }
 }

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

@@ -36,6 +36,7 @@ final class RefasterRulesTest {
           AssortedRules.class,
           BigDecimalRules.class,
           BugCheckerRules.class,
+          CharSequenceRules.class,
           ClassRules.class,
           CollectionRules.class,
           ComparatorRules.class,

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

@@ -0,0 +1,16 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.common.collect.ImmutableSet;
+import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
+
+final class CharSequenceRulesTest implements RefasterRuleCollectionTestCase {
+  ImmutableSet<Boolean> testCharSequenceIsEmpty() {
+    return ImmutableSet.of(
+        new StringBuilder("foo").length() == 0,
+        new StringBuilder("bar").length() <= 0,
+        new StringBuilder("baz").length() < 1,
+        new StringBuilder("qux").length() != 0,
+        new StringBuilder("quux").length() > 0,
+        new StringBuilder("corge").length() >= 1);
+  }
+}

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

@@ -0,0 +1,16 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.common.collect.ImmutableSet;
+import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
+
+final class CharSequenceRulesTest implements RefasterRuleCollectionTestCase {
+  ImmutableSet<Boolean> testCharSequenceIsEmpty() {
+    return ImmutableSet.of(
+        new StringBuilder("foo").isEmpty(),
+        new StringBuilder("bar").isEmpty(),
+        new StringBuilder("baz").isEmpty(),
+        !new StringBuilder("qux").isEmpty(),
+        !new StringBuilder("quux").isEmpty(),
+        !new StringBuilder("corge").isEmpty());
+  }
+}

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

@@ -28,9 +28,9 @@ final class StringRulesTest implements RefasterRuleCollectionTestCase {
         "foo".length() == 0,
         "bar".length() <= 0,
         "baz".length() < 1,
-        "foo".length() != 0,
-        "bar".length() > 0,
-        "baz".length() >= 1);
+        "qux".length() != 0,
+        "quux".length() > 0,
+        "corge".length() >= 1);
   }
 
   boolean testStringIsEmptyPredicate() {
@@ -124,4 +124,8 @@ final class StringRulesTest implements RefasterRuleCollectionTestCase {
   boolean testStringStartsWith() {
     return "foo".substring(1).startsWith("bar");
   }
+
+  String testStringFormatted() {
+    return String.format("%s%s", "foo", "bar");
+  }
 }

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

@@ -31,9 +31,9 @@ final class StringRulesTest implements RefasterRuleCollectionTestCase {
         "foo".isEmpty(),
         "bar".isEmpty(),
         "baz".isEmpty(),
-        !"foo".isEmpty(),
-        !"bar".isEmpty(),
-        !"baz".isEmpty());
+        !"qux".isEmpty(),
+        !"quux".isEmpty(),
+        !"corge".isEmpty());
   }
 
   boolean testStringIsEmptyPredicate() {
@@ -124,4 +124,8 @@ final class StringRulesTest implements RefasterRuleCollectionTestCase {
   boolean testStringStartsWith() {
     return "foo".startsWith("bar", 1);
   }
+
+  String testStringFormatted() {
+    return "%s%s".formatted("foo", "bar");
+  }
 }