From c59cb4a9474ce1e06c2bd72ec15f6384c8e40b6b Mon Sep 17 00:00:00 2001 From: Rick Ossendrijver Date: Fri, 4 Apr 2025 08:17:42 +0200 Subject: [PATCH] Add `Refaster#AnyOf` use cases --- .../refaster/runner/RefasterRuleSelector.java | 25 +++++++-------- .../test/NestedRefasterAnyOfRules.java | 31 +++++++++++++++++++ .../test/RefasterRuleCollectionTest.java | 2 ++ .../test/SingleRefasterAnyOfRules.java | 27 ++++++++++++++++ .../NestedRefasterAnyOfRulesTestInput.java | 12 +++++++ .../NestedRefasterAnyOfRulesTestOutput.java | 12 +++++++ .../SingleRefasterAnyOfRulesTestInput.java | 17 ++++++++++ .../SingleRefasterAnyOfRulesTestOutput.java | 18 +++++++++++ 8 files changed, 130 insertions(+), 14 deletions(-) create mode 100644 refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRules.java create mode 100644 refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRules.java create mode 100644 refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestInput.java create mode 100644 refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestOutput.java create mode 100644 refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestInput.java create mode 100644 refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestOutput.java diff --git a/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/RefasterRuleSelector.java b/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/RefasterRuleSelector.java index b0b22e2b..87f6d0ce 100644 --- a/refaster-runner/src/main/java/tech/picnic/errorprone/refaster/runner/RefasterRuleSelector.java +++ b/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>> identifiers) { - if (codeTransformer instanceof CompositeCodeTransformer) { - for (CodeTransformer transformer : - ((CompositeCodeTransformer) codeTransformer).transformers()) { + if (codeTransformer instanceof CompositeCodeTransformer compositeCodeTransformer) { + for (CodeTransformer transformer : compositeCodeTransformer.transformers()) { collectRuleIdentifiers(transformer, identifiers); } - } else if (codeTransformer instanceof AnnotatedCompositeCodeTransformer) { - AnnotatedCompositeCodeTransformer annotatedTransformer = - (AnnotatedCompositeCodeTransformer) codeTransformer; + } else if (codeTransformer instanceof AnnotatedCompositeCodeTransformer annotatedTransformer) { for (Map.Entry>> e : indexRuleIdentifiers(annotatedTransformer.transformers()).entrySet()) { identifiers.put(annotatedTransformer.withTransformers(e.getKey()), e.getValue()); @@ -160,12 +157,12 @@ final class RefasterRuleSelector { ImmutableSet.Builder> results = ImmutableSet.builder(); for (Object template : RefasterIntrospection.getBeforeTemplates(refasterRule)) { - if (template instanceof ExpressionTemplate) { - UExpression expr = RefasterIntrospection.getExpression((ExpressionTemplate) template); + if (template instanceof ExpressionTemplate expressionTemplate) { + UExpression expr = RefasterIntrospection.getExpression(expressionTemplate); results.addAll(extractRuleIdentifiers(ImmutableList.of(expr))); - } else if (template instanceof BlockTemplate) { + } else if (template instanceof BlockTemplate blockTemplate) { ImmutableList 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) { - IdentifierTree subNode = RefasterIntrospection.getClassIdent((UStaticIdent) node); + } else if (node instanceof UStaticIdent uStaticIdent) { + IdentifierTree subNode = RefasterIntrospection.getClassIdent(uStaticIdent); for (Set 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> identifierCombinations) { - if (node instanceof UAnyOf) { + if (node instanceof UAnyOf uAnyOf) { List> base = copy(identifierCombinations); identifierCombinations.clear(); - for (UExpression expr : RefasterIntrospection.getExpressions((UAnyOf) node)) { + for (UExpression expr : RefasterIntrospection.getExpressions(uAnyOf)) { List> branch = copy(base); scan(expr, branch); identifierCombinations.addAll(branch); diff --git a/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRules.java b/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRules.java new file mode 100644 index 00000000..15b6d49d --- /dev/null +++ b/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 { + @BeforeTemplate + @SuppressWarnings({"ImmutableMapOf1", "MapEntry"} /* Similar rules for testing purposes. */) + Map 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 after(K k1, V v1) { + return ImmutableMap.of(k1, v1); + } + } +} diff --git a/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTest.java b/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTest.java index 1f38eaea..d5ec25bc 100644 --- a/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/RefasterRuleCollectionTest.java +++ b/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) { diff --git a/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRules.java b/refaster-test-support/src/test/java/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRules.java new file mode 100644 index 00000000..30a64e80 --- /dev/null +++ b/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 { + @BeforeTemplate + @SuppressWarnings("ImmutableMapOf1" /* Similar rule for testing purposes. */) + Map before(K k1, V v1) { + return Refaster.anyOf(ImmutableMap.ofEntries(Map.entry(k1, v1)), singletonMap(k1, v1)); + } + + @AfterTemplate + ImmutableMap after(K k1, V v1) { + return ImmutableMap.of(k1, v1); + } + } +} diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestInput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestInput.java new file mode 100644 index 00000000..529ce902 --- /dev/null +++ b/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 stringStringMap = Map.of("1", "2"); + return ImmutableMap.ofEntries(Map.entry("k1", "v1")); + } +} diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestOutput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/NestedRefasterAnyOfRulesTestOutput.java new file mode 100644 index 00000000..fd5dd391 --- /dev/null +++ b/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 stringStringMap = Map.of("1", "2"); + return ImmutableMap.of("k1", "v1"); + } +} diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestInput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestInput.java new file mode 100644 index 00000000..3e4ec983 --- /dev/null +++ b/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 elidedTypesAndStaticImports() { + return ImmutableSet.of(Collections.class); + } + + Map testSingleRefasterAnyOf() { + return Collections.singletonMap("k1", "v1"); + } +} diff --git a/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestOutput.java b/refaster-test-support/src/test/resources/tech/picnic/errorprone/refaster/test/SingleRefasterAnyOfRulesTestOutput.java new file mode 100644 index 00000000..20c61b99 --- /dev/null +++ b/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 elidedTypesAndStaticImports() { + return ImmutableSet.of(Collections.class); + } + + Map testSingleRefasterAnyOf() { + return ImmutableMap.of("k1", "v1"); + } +}