Introduce PatternRules Refaster rule collection

While there, configure `StaticImport` to not require static importing of
`com.google.common.base.Predicates.contains`.

See google/guava#6483.

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

@@ -155,6 +155,7 @@ public final class StaticImport extends BugChecker implements MemberSelectTreeMa
  @VisibleForTesting
  static final ImmutableSetMultimap<String, String> STATIC_IMPORT_EXEMPTED_MEMBERS =
  ImmutableSetMultimap.<String, String>builder()
+ .put("com.google.common.base.Predicates", "contains")
  .put("com.mongodb.client.model.Filters", "empty")
  .putAll(
  "java.util.Collections",

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

@@ -0,0 +1,46 @@
+package tech.picnic.errorprone.refasterrules;
+
+import static com.google.common.base.Predicates.containsPattern;
+
+import com.google.common.base.Predicates;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import tech.picnic.errorprone.refaster.annotation.OnlineDocumentation;
+
+/** Refaster rules related to code dealing with regular expressions. */
+@OnlineDocumentation
+final class PatternRules {
+ private PatternRules() {}
+
+ /** Prefer {@link Pattern#asPredicate()} over non-JDK alternatives. */
+ // XXX: This rule could also replace `s -> pattern.matcher(s).find()`, though the lambda
+ // expression may match functional interfaces other than `Predicate`. If we do add such a rule, we
+ // should also add a rule that replaces `s -> pattern.matcher(s).matches()` with
+ // `pattern.asMatchPredicate()`.
+ static final class PatternAsPredicate {
+ @BeforeTemplate
+ Predicate<CharSequence> before(Pattern pattern) {
+ return Predicates.contains(pattern);
+ }
+
+ @AfterTemplate
+ Predicate<String> after(Pattern pattern) {
+ return pattern.asPredicate();
+ }
+ }
+
+ /** Prefer {@link Pattern#asPredicate()} over non-JDK alternatives. */
+ static final class PatternCompileAsPredicate {
+ @BeforeTemplate
+ Predicate<CharSequence> before(String pattern) {
+ return containsPattern(pattern);
+ }
+
+ @AfterTemplate
+ Predicate<String> after(String pattern) {
+ return Pattern.compile(pattern).asPredicate();
+ }
+ }
+}

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

@@ -0,0 +1,22 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableSet;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
+
+final class PatternRulesTest implements RefasterRuleCollectionTestCase {
+ @Override
+ public ImmutableSet<Object> elidedTypesAndStaticImports() {
+ return ImmutableSet.of(Predicates.class);
+ }
+
+ Predicate<?> testPatternAsPredicate() {
+ return Predicates.contains(Pattern.compile("foo"));
+ }
+
+ Predicate<?> testPatternCompileAsPredicate() {
+ return Predicates.containsPattern("foo");
+ }
+}

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

@@ -0,0 +1,22 @@
+package tech.picnic.errorprone.refasterrules;
+
+import com.google.common.base.Predicates;
+import com.google.common.collect.ImmutableSet;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import tech.picnic.errorprone.refaster.test.RefasterRuleCollectionTestCase;
+
+final class PatternRulesTest implements RefasterRuleCollectionTestCase {
+ @Override
+ public ImmutableSet<Object> elidedTypesAndStaticImports() {
+ return ImmutableSet.of(Predicates.class);
+ }
+
+ Predicate<?> testPatternAsPredicate() {
+ return Pattern.compile("foo").asPredicate();
+ }
+
+ Predicate<?> testPatternCompileAsPredicate() {
+ return Pattern.compile("foo").asPredicate();
+ }
+}