Add Refaster#AnyOf use cases

refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/RefasterRuleSelector.java

@@ -132,14 +132,11 @@ final class RefasterRuleSelector {
   private static void collectRuleIdentifiers(
       CodeTransformer codeTransformer,
       Map<CodeTransformer, ImmutableSet<ImmutableSet<String>>> identifiers) {
-    if (codeTransformer instanceof CompositeCodeTransformer) {
+    if (codeTransformer instanceof CompositeCodeTransformer compositeCodeTransformer) {
-      for (CodeTransformer transformer :
+      for (CodeTransformer transformer : compositeCodeTransformer.transformers()) {
-          ((CompositeCodeTransformer) codeTransformer).transformers()) {
         collectRuleIdentifiers(transformer, identifiers);
       }
-    } else if (codeTransformer instanceof AnnotatedCompositeCodeTransformer) {
+    } else if (codeTransformer instanceof AnnotatedCompositeCodeTransformer annotatedTransformer) {
-      AnnotatedCompositeCodeTransformer annotatedTransformer =
-          (AnnotatedCompositeCodeTransformer) codeTransformer;
       for (Map.Entry<CodeTransformer, ImmutableSet<ImmutableSet<String>>> e :
           indexRuleIdentifiers(annotatedTransformer.transformers()).entrySet()) {
         identifiers.put(annotatedTransformer.withTransformers(e.getKey()), e.getValue());
@@ -160,12 +157,12 @@ final class RefasterRuleSelector {
     ImmutableSet.Builder<ImmutableSet<String>> results = ImmutableSet.builder();
 
     for (Object template : RefasterIntrospection.getBeforeTemplates(refasterRule)) {
-      if (template instanceof ExpressionTemplate) {
+      if (template instanceof ExpressionTemplate expressionTemplate) {
-        UExpression expr = RefasterIntrospection.getExpression((ExpressionTemplate) template);
+        UExpression expr = RefasterIntrospection.getExpression(expressionTemplate);
         results.addAll(extractRuleIdentifiers(ImmutableList.of(expr)));
-      } else if (template instanceof BlockTemplate) {
+      } else if (template instanceof BlockTemplate blockTemplate) {
         ImmutableList<UStatement> statements =
-            RefasterIntrospection.getTemplateStatements((BlockTemplate) template);
+            RefasterIntrospection.getTemplateStatements(blockTemplate);
         results.addAll(extractRuleIdentifiers(statements));
       } else {
         throw new IllegalStateException(
@@ -333,8 +330,8 @@ final class RefasterRuleSelector {
           ids.add(getSimpleName(RefasterIntrospection.getTopLevelClass(node)));
           ids.add(getIdentifier(node));
         }
-      } else if (node instanceof UStaticIdent) {
+      } else if (node instanceof UStaticIdent uStaticIdent) {
-        IdentifierTree subNode = RefasterIntrospection.getClassIdent((UStaticIdent) node);
+        IdentifierTree subNode = RefasterIntrospection.getClassIdent(uStaticIdent);
         for (Set<String> ids : identifierCombinations) {
           ids.add(getSimpleName(RefasterIntrospection.getTopLevelClass(subNode)));
           ids.add(getIdentifier(subNode));
@@ -406,11 +403,11 @@ final class RefasterRuleSelector {
 
     @Override
     public @Nullable Void visitOther(Tree node, List<Set<String>> identifierCombinations) {
-      if (node instanceof UAnyOf) {
+      if (node instanceof UAnyOf uAnyOf) {
         List<Set<String>> base = copy(identifierCombinations);
         identifierCombinations.clear();
 
-        for (UExpression expr : RefasterIntrospection.getExpressions((UAnyOf) node)) {
+        for (UExpression expr : RefasterIntrospection.getExpressions(uAnyOf)) {
           List<Set<String>> branch = copy(base);
           scan(expr, branch);
           identifierCombinations.addAll(branch);

refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRules.java

@@ -0,0 +1,31 @@
+package tech.picnic.errorprone.refaster.test;
+
+import static java.util.Collections.singletonMap;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.AbstractMap.SimpleImmutableEntry;
+import java.util.Map;
+
+/** Refaster rule collection to validate the reporting of missing test methods. */
+final class NestedRefasterAnyOfRules {
+  private NestedRefasterAnyOfRules() {}
+
+  static final class NestedRefasterAnyOf<K, V> {
+    @BeforeTemplate
+    @SuppressWarnings({"ImmutableMapOf1", "MapEntry"} /* Similar rules for testing purposes. */)
+    Map<K, V> before(K k1, V v1) {
+      return Refaster.anyOf(
+          ImmutableMap.ofEntries(
+              Refaster.anyOf(Map.entry(k1, v1), new SimpleImmutableEntry<>(k1, v1))),
+          singletonMap(k1, v1));
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1) {
+      return ImmutableMap.of(k1, v1);
+    }
+  }
+}

refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTest.java

@@ -21,8 +21,10 @@ final class RefasterRuleCollectionTest {
         MethodWithoutPrefixRules.class,
         MisnamedTestClassRules.class,
         MissingTestAndWrongTestRules.class,
+        NestedRefasterAnyOfRules.class,
         PartialTestMatchRules.class,
         RuleWithoutTestRules.class,
+        SingleRefasterAnyOfRules.class,
         ValidRules.class
       })
   void verifyRefasterRuleCollections(Class<?> clazz) {

refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRules.java

@@ -0,0 +1,27 @@
+package tech.picnic.errorprone.refaster.test;
+
+import static java.util.Collections.singletonMap;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.refaster.Refaster;
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import java.util.Map;
+
+/** Refaster rule collection to validate the reporting of missing test methods. */
+final class SingleRefasterAnyOfRules {
+  private SingleRefasterAnyOfRules() {}
+
+  static final class SingleRefasterAnyOf<K, V> {
+    @BeforeTemplate
+    @SuppressWarnings("ImmutableMapOf1" /* Similar rule for testing purposes. */)
+    Map<K, V> before(K k1, V v1) {
+      return Refaster.anyOf(ImmutableMap.ofEntries(Map.entry(k1, v1)), singletonMap(k1, v1));
+    }
+
+    @AfterTemplate
+    ImmutableMap<K, V> after(K k1, V v1) {
+      return ImmutableMap.of(k1, v1);
+    }
+  }
+}

refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestInput.java

@@ -0,0 +1,12 @@
+package tech.picnic.errorprone.refaster.test;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.Map;
+
+/** Code to test the Refaster rules from {@link NestedRefasterAnyOfRules}. */
+final class NestedRefasterAnyOfRulesTest implements RefasterRuleCollectionTestCase {
+  Map<?, ?> testNestedRefasterAnyOf() {
+    Map<String, String> stringStringMap = Map.of("1", "2");
+    return ImmutableMap.ofEntries(Map.entry("k1", "v1"));
+  }
+}

refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestOutput.java

@@ -0,0 +1,12 @@
+package tech.picnic.errorprone.refaster.test;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.Map;
+
+/** Code to test the Refaster rules from {@link NestedRefasterAnyOfRules}. */
+final class NestedRefasterAnyOfRulesTest implements RefasterRuleCollectionTestCase {
+  Map<?, ?> testNestedRefasterAnyOf() {
+    Map<String, String> stringStringMap = Map.of("1", "2");
+    return ImmutableMap.of("k1", "v1");
+  }
+}

refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestInput.java

@@ -0,0 +1,17 @@
+package tech.picnic.errorprone.refaster.test;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.Collections;
+import java.util.Map;
+
+/** Code to test the Refaster rules from {@link SingleRefasterAnyOfRules}. */
+final class SingleRefasterAnyOfRulesTest implements RefasterRuleCollectionTestCase {
+  @Override
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
+    return ImmutableSet.of(Collections.class);
+  }
+
+  Map<?, ?> testSingleRefasterAnyOf() {
+    return Collections.singletonMap("k1", "v1");
+  }
+}

refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestOutput.java

@@ -0,0 +1,18 @@
+package tech.picnic.errorprone.refaster.test;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import java.util.Collections;
+import java.util.Map;
+
+/** Code to test the Refaster rules from {@link SingleRefasterAnyOfRules}. */
+final class SingleRefasterAnyOfRulesTest implements RefasterRuleCollectionTestCase {
+  @Override
+  public ImmutableSet<Object> elidedTypesAndStaticImports() {
+    return ImmutableSet.of(Collections.class);
+  }
+
+  Map<?, ?> testSingleRefasterAnyOf() {
+    return ImmutableMap.of("k1", "v1");
+  }
+}