diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversionCheck.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversionCheck.java new file mode 100644 index 0000000000..9fb3587dcc --- /dev/null +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/bugpatterns/IdentityConversionCheck.java @@ -0,0 +1,111 @@ +package tech.picnic.errorprone.bugpatterns; + +import static com.google.common.collect.ImmutableSet.toImmutableSet; +import static com.google.errorprone.BugPattern.LinkType.NONE; +import static com.google.errorprone.BugPattern.SeverityLevel.WARNING; +import static com.google.errorprone.BugPattern.StandardTags.SIMPLIFICATION; +import static com.google.errorprone.matchers.Matchers.anyOf; +import static com.google.errorprone.matchers.Matchers.staticMethod; +import static com.google.errorprone.suppliers.Suppliers.OBJECT_TYPE; + +import com.google.auto.service.AutoService; +import com.google.common.primitives.Primitives; +import com.google.errorprone.BugPattern; +import com.google.errorprone.VisitorState; +import com.google.errorprone.bugpatterns.BugChecker; +import com.google.errorprone.bugpatterns.BugChecker.MethodInvocationTreeMatcher; +import com.google.errorprone.bugpatterns.TypesWithUndefinedEquality; +import com.google.errorprone.fixes.SuggestedFix; +import com.google.errorprone.fixes.SuggestedFixes; +import com.google.errorprone.matchers.Description; +import com.google.errorprone.matchers.Matcher; +import com.google.errorprone.util.ASTHelpers; +import com.google.errorprone.util.ASTHelpers.TargetType; +import com.sun.source.tree.ExpressionTree; +import com.sun.source.tree.MethodInvocationTree; +import com.sun.tools.javac.code.Type; +import com.sun.tools.javac.code.Types; +import java.util.Arrays; +import java.util.List; + +/** A {@link BugChecker} that flags redundant identity conversions. */ +// XXX: Consider detecting cases where a flagged expression is passed to a method, and where removal +// of the identify conversion would cause a different method overload to be selected. Depending on +// the target method such a modification may change the code's semantics or performance. +@AutoService(BugChecker.class) +@BugPattern( + name = "IdentityConversion", + summary = "Avoid or clarify identity conversions", + linkType = NONE, + severity = WARNING, + tags = SIMPLIFICATION) +public final class IdentityConversionCheck extends BugChecker + implements MethodInvocationTreeMatcher { + private static final long serialVersionUID = 1L; + private static final Matcher<ExpressionTree> IS_CONVERSION_METHOD = + anyOf( + staticMethod() + .onClassAny( + "com.google.common.collect.ImmutableBiMap", + "com.google.common.collect.ImmutableList", + "com.google.common.collect.ImmutableListMultimap", + "com.google.common.collect.ImmutableMap", + "com.google.common.collect.ImmutableMultimap", + "com.google.common.collect.ImmutableMultiset", + "com.google.common.collect.ImmutableRangeMap", + "com.google.common.collect.ImmutableRangeSet", + "com.google.common.collect.ImmutableSet", + "com.google.common.collect.ImmutableSetMultimap", + "com.google.common.collect.ImmutableTable") + .named("copyOf"), + staticMethod() + .onClassAny( + Primitives.allWrapperTypes().stream() + .map(Class::getName) + .collect(toImmutableSet())) + .named("valueOf"), + staticMethod().onClass(String.class.getName()).named("valueOf"), + staticMethod().onClass("reactor.adapter.rxjava.RxJava2Adapter"), + staticMethod() + .onClass("reactor.core.publisher.Flux") + .namedAnyOf("concat", "firstWithSignal", "from", "merge"), + staticMethod().onClass("reactor.core.publisher.Mono").namedAnyOf("from", "fromDirect")); + + @Override + public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { + List<? extends ExpressionTree> arguments = tree.getArguments(); + if (arguments.size() != 1 || !IS_CONVERSION_METHOD.matches(tree, state)) { + return Description.NO_MATCH; + } + + ExpressionTree sourceTree = arguments.get(0); + Type sourceType = ASTHelpers.getType(sourceTree); + Type resultType = ASTHelpers.getType(tree); + TargetType targetType = ASTHelpers.targetType(state); + if (sourceType == null || resultType == null || targetType == null) { + return Description.NO_MATCH; + } + + if (!state.getTypes().isSameType(sourceType, resultType) + && !isConvertibleWithWellDefinedEquality(sourceType, targetType.type(), state)) { + return Description.NO_MATCH; + } + + return buildDescription(tree) + .setMessage( + "This method invocation appears redundant; remove it or suppress this warning and " + + "add a comment explaining its purpose") + .addFix(SuggestedFix.replace(tree, Util.treeToString(sourceTree, state))) + .addFix(SuggestedFixes.addSuppressWarnings(state, canonicalName())) + .build(); + } + + private static boolean isConvertibleWithWellDefinedEquality( + Type sourceType, Type targetType, VisitorState state) { + Types types = state.getTypes(); + return !types.isSameType(targetType, OBJECT_TYPE.get(state)) + && types.isConvertible(sourceType, targetType) + && Arrays.stream(TypesWithUndefinedEquality.values()) + .noneMatch(b -> b.matchesType(sourceType, state) || b.matchesType(targetType, state)); + } +} diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJByteTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJByteTemplates.java index 97f86e6331..220e3001e7 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJByteTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJByteTemplates.java @@ -15,11 +15,7 @@ static final class AbstractByteAssertIsEqualTo { @BeforeTemplate AbstractByteAssert<?> before(AbstractByteAssert<?> byteAssert, byte n) { return Refaster.anyOf( - byteAssert.isCloseTo(n, offset((byte) 0)), - byteAssert.isCloseTo(Byte.valueOf(n), offset((byte) 0)), - byteAssert.isCloseTo(n, withPercentage(0)), - byteAssert.isCloseTo(Byte.valueOf(n), withPercentage(0)), - byteAssert.isEqualTo(Byte.valueOf(n))); + byteAssert.isCloseTo(n, offset((byte) 0)), byteAssert.isCloseTo(n, withPercentage(0))); } @AfterTemplate @@ -33,10 +29,7 @@ static final class AbstractByteAssertIsNotEqualTo { AbstractByteAssert<?> before(AbstractByteAssert<?> byteAssert, byte n) { return Refaster.anyOf( byteAssert.isNotCloseTo(n, offset((byte) 0)), - byteAssert.isNotCloseTo(Byte.valueOf(n), offset((byte) 0)), - byteAssert.isNotCloseTo(n, withPercentage(0)), - byteAssert.isNotCloseTo(Byte.valueOf(n), withPercentage(0)), - byteAssert.isNotEqualTo(Byte.valueOf(n))); + byteAssert.isNotCloseTo(n, withPercentage(0))); } @AfterTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJDoubleTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJDoubleTemplates.java index b158aad75f..44dc57b014 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJDoubleTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJDoubleTemplates.java @@ -36,11 +36,7 @@ static final class AbstractDoubleAssertIsEqualTo { @BeforeTemplate AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert, double n) { return Refaster.anyOf( - doubleAssert.isCloseTo(n, offset(0.0)), - doubleAssert.isCloseTo(Double.valueOf(n), offset(0.0)), - doubleAssert.isCloseTo(n, withPercentage(0.0)), - doubleAssert.isCloseTo(Double.valueOf(n), withPercentage(0.0)), - doubleAssert.isEqualTo(Double.valueOf(n))); + doubleAssert.isCloseTo(n, offset(0.0)), doubleAssert.isCloseTo(n, withPercentage(0.0))); } @AfterTemplate @@ -54,10 +50,7 @@ static final class AbstractDoubleAssertIsNotEqualTo { AbstractDoubleAssert<?> before(AbstractDoubleAssert<?> doubleAssert, double n) { return Refaster.anyOf( doubleAssert.isNotCloseTo(n, offset(0.0)), - doubleAssert.isNotCloseTo(Double.valueOf(n), offset(0.0)), - doubleAssert.isNotCloseTo(n, withPercentage(0.0)), - doubleAssert.isNotCloseTo(Double.valueOf(n), withPercentage(0.0)), - doubleAssert.isNotEqualTo(Double.valueOf(n))); + doubleAssert.isNotCloseTo(n, withPercentage(0.0))); } @AfterTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJFloatTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJFloatTemplates.java index 059e2667d8..6de54b99cb 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJFloatTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJFloatTemplates.java @@ -36,11 +36,7 @@ static final class AbstractFloatAssertIsEqualTo { @BeforeTemplate AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert, float n) { return Refaster.anyOf( - floatAssert.isCloseTo(n, offset(0F)), - floatAssert.isCloseTo(Float.valueOf(n), offset(0F)), - floatAssert.isCloseTo(n, withPercentage(0)), - floatAssert.isCloseTo(Float.valueOf(n), withPercentage(0)), - floatAssert.isEqualTo(Float.valueOf(n))); + floatAssert.isCloseTo(n, offset(0F)), floatAssert.isCloseTo(n, withPercentage(0))); } @AfterTemplate @@ -53,11 +49,7 @@ static final class AbstractFloatAssertIsNotEqualTo { @BeforeTemplate AbstractFloatAssert<?> before(AbstractFloatAssert<?> floatAssert, float n) { return Refaster.anyOf( - floatAssert.isNotCloseTo(n, offset(0F)), - floatAssert.isNotCloseTo(Float.valueOf(n), offset(0F)), - floatAssert.isNotCloseTo(n, withPercentage(0)), - floatAssert.isNotCloseTo(Float.valueOf(n), withPercentage(0)), - floatAssert.isNotEqualTo(Float.valueOf(n))); + floatAssert.isNotCloseTo(n, offset(0F)), floatAssert.isNotCloseTo(n, withPercentage(0))); } @AfterTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJIntegerTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJIntegerTemplates.java index f8ee52c6a7..f46ac40564 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJIntegerTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJIntegerTemplates.java @@ -15,11 +15,7 @@ static final class AbstractIntegerAssertIsEqualTo { @BeforeTemplate AbstractIntegerAssert<?> before(AbstractIntegerAssert<?> intAssert, int n) { return Refaster.anyOf( - intAssert.isCloseTo(n, offset(0)), - intAssert.isCloseTo(Integer.valueOf(n), offset(0)), - intAssert.isCloseTo(n, withPercentage(0)), - intAssert.isCloseTo(Integer.valueOf(n), withPercentage(0)), - intAssert.isEqualTo(Integer.valueOf(n))); + intAssert.isCloseTo(n, offset(0)), intAssert.isCloseTo(n, withPercentage(0))); } @AfterTemplate @@ -32,11 +28,7 @@ static final class AbstractIntegerAssertIsNotEqualTo { @BeforeTemplate AbstractIntegerAssert<?> before(AbstractIntegerAssert<?> intAssert, int n) { return Refaster.anyOf( - intAssert.isNotCloseTo(n, offset(0)), - intAssert.isNotCloseTo(Integer.valueOf(n), offset(0)), - intAssert.isNotCloseTo(n, withPercentage(0)), - intAssert.isNotCloseTo(Integer.valueOf(n), withPercentage(0)), - intAssert.isNotEqualTo(Integer.valueOf(n))); + intAssert.isNotCloseTo(n, offset(0)), intAssert.isNotCloseTo(n, withPercentage(0))); } @AfterTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJLongTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJLongTemplates.java index 9e6de98b74..e992886dff 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJLongTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJLongTemplates.java @@ -15,11 +15,7 @@ static final class AbstractLongAssertIsEqualTo { @BeforeTemplate AbstractLongAssert<?> before(AbstractLongAssert<?> longAssert, long n) { return Refaster.anyOf( - longAssert.isCloseTo(n, offset(0L)), - longAssert.isCloseTo(Long.valueOf(n), offset(0L)), - longAssert.isCloseTo(n, withPercentage(0)), - longAssert.isCloseTo(Long.valueOf(n), withPercentage(0)), - longAssert.isEqualTo(Long.valueOf(n))); + longAssert.isCloseTo(n, offset(0L)), longAssert.isCloseTo(n, withPercentage(0))); } @AfterTemplate @@ -32,11 +28,7 @@ static final class AbstractLongAssertIsNotEqualTo { @BeforeTemplate AbstractLongAssert<?> before(AbstractLongAssert<?> longAssert, long n) { return Refaster.anyOf( - longAssert.isNotCloseTo(n, offset(0L)), - longAssert.isNotCloseTo(Long.valueOf(n), offset(0L)), - longAssert.isNotCloseTo(n, withPercentage(0)), - longAssert.isNotCloseTo(Long.valueOf(n), withPercentage(0)), - longAssert.isNotEqualTo(Long.valueOf(n))); + longAssert.isNotCloseTo(n, offset(0L)), longAssert.isNotCloseTo(n, withPercentage(0))); } @AfterTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJShortTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJShortTemplates.java index dd71b89961..017f897b93 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJShortTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/AssertJShortTemplates.java @@ -15,11 +15,7 @@ static final class AbstractShortAssertIsEqualTo { @BeforeTemplate AbstractShortAssert<?> before(AbstractShortAssert<?> shortAssert, short n) { return Refaster.anyOf( - shortAssert.isCloseTo(n, offset((short) 0)), - shortAssert.isCloseTo(Short.valueOf(n), offset((short) 0)), - shortAssert.isCloseTo(n, withPercentage(0)), - shortAssert.isCloseTo(Short.valueOf(n), withPercentage(0)), - shortAssert.isEqualTo(Short.valueOf(n))); + shortAssert.isCloseTo(n, offset((short) 0)), shortAssert.isCloseTo(n, withPercentage(0))); } @AfterTemplate @@ -33,10 +29,7 @@ static final class AbstractShortAssertIsNotEqualTo { AbstractShortAssert<?> before(AbstractShortAssert<?> shortAssert, short n) { return Refaster.anyOf( shortAssert.isNotCloseTo(n, offset((short) 0)), - shortAssert.isNotCloseTo(Short.valueOf(n), offset((short) 0)), - shortAssert.isNotCloseTo(n, withPercentage(0)), - shortAssert.isNotCloseTo(Short.valueOf(n), withPercentage(0)), - shortAssert.isNotEqualTo(Short.valueOf(n))); + shortAssert.isNotCloseTo(n, withPercentage(0))); } @AfterTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListMultimapTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListMultimapTemplates.java index 43b1c04c21..61b39db642 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListMultimapTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableListMultimapTemplates.java @@ -272,17 +272,4 @@ ImmutableListMultimap<K, V2> after( return ImmutableListMultimap.copyOf(Multimaps.transformValues(multimap, transformation)); } } - - /** Don't unnecessarily copy an {@link ImmutableListMultimap}. */ - static final class ImmutableListMultimapCopyOfImmutableListMultimap<K, V> { - @BeforeTemplate - ImmutableListMultimap<K, V> before(ImmutableListMultimap<K, V> multimap) { - return ImmutableListMultimap.copyOf(multimap); - } - - @AfterTemplate - ImmutableListMultimap<K, V> after(ImmutableListMultimap<K, V> multimap) { - return multimap; - } - } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java index 03f0690988..9c307a8e3a 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMapTemplates.java @@ -242,19 +242,6 @@ ImmutableMap<K, V2> after(Map<K, V1> map) { } } - /** Don't unnecessarily copy an {@link ImmutableMap}. */ - static final class ImmutableMapCopyOfImmutableMap<K, V> { - @BeforeTemplate - ImmutableMap<K, V> before(ImmutableMap<K, V> map) { - return ImmutableMap.copyOf(map); - } - - @AfterTemplate - ImmutableMap<K, V> after(ImmutableMap<K, V> map) { - return map; - } - } - // XXX: Add a template for this: // Maps.transformValues(streamOfEntries.collect(groupBy(fun)), ImmutableMap::copyOf) // -> diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMultisetTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMultisetTemplates.java index 4f7aa4aa92..adb6a0f5e3 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMultisetTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableMultisetTemplates.java @@ -101,17 +101,4 @@ ImmutableMultiset<T> after(Stream<T> stream) { return stream.collect(toImmutableMultiset()); } } - - /** Don't unnecessarily copy an {@link ImmutableMultiset}. */ - static final class ImmutableMultisetCopyOfImmutableMultiset<T> { - @BeforeTemplate - ImmutableMultiset<T> before(ImmutableMultiset<T> multiset) { - return ImmutableMultiset.copyOf(multiset); - } - - @AfterTemplate - ImmutableMultiset<T> after(ImmutableMultiset<T> multiset) { - return multiset; - } - } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java index d851cbaeb8..01f4b5488f 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetMultimapTemplates.java @@ -215,17 +215,4 @@ ImmutableSetMultimap<K, V2> after( return ImmutableSetMultimap.copyOf(Multimaps.transformValues(multimap, transformation)); } } - - /** Don't unnecessarily copy an {@link ImmutableSetMultimap}. */ - static final class ImmutableSetMultimapCopyOfImmutableSetMultimap<K, V> { - @BeforeTemplate - ImmutableSetMultimap<K, V> before(ImmutableSetMultimap<K, V> multimap) { - return ImmutableSetMultimap.copyOf(multimap); - } - - @AfterTemplate - ImmutableSetMultimap<K, V> after(ImmutableSetMultimap<K, V> multimap) { - return multimap; - } - } } diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java index 077bddf428..f2391b9cd5 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ImmutableSetTemplates.java @@ -126,19 +126,6 @@ ImmutableSet<T> after(Stream<T> stream) { } } - /** Don't unnecessarily copy an {@link ImmutableSet}. */ - static final class ImmutableSetCopyOfImmutableSet<T> { - @BeforeTemplate - ImmutableSet<T> before(ImmutableSet<T> set) { - return ImmutableSet.copyOf(set); - } - - @AfterTemplate - ImmutableSet<T> after(ImmutableSet<T> set) { - return set; - } - } - /** Prefer {@link SetView#immutableCopy()} over the more verbose alternative. */ static final class ImmutableSetCopyOfSetView<T> { @BeforeTemplate diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ReactorTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ReactorTemplates.java index 3f93e629fd..74143680cb 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ReactorTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/ReactorTemplates.java @@ -203,19 +203,6 @@ Flux<T> after(Mono<T> mono) { } } - /** Don't unnecessarily invoke {@link Flux#concat(Publisher)}. */ - static final class FluxIdentity<T> { - @BeforeTemplate - Flux<T> before(Flux<T> flux) { - return Flux.concat(flux); - } - - @AfterTemplate - Flux<T> after(Flux<T> flux) { - return flux; - } - } - /** * Prefer a collection using {@link MoreCollectors#toOptional()} over more contrived alternatives. */ diff --git a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplates.java b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplates.java index 6dfac5f109..566248f74f 100644 --- a/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplates.java +++ b/error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJava2AdapterTemplates.java @@ -41,11 +41,9 @@ static final class FlowableToFlux<T> { @BeforeTemplate Publisher<T> before(Flowable<T> flowable) { return Refaster.anyOf( - Flux.from(flowable), flowable.compose(Flux::from), flowable.to(Flux::from), flowable.as(Flux::from), - RxJava2Adapter.flowableToFlux(flowable), flowable.compose(RxJava2Adapter::flowableToFlux), flowable.to(RxJava2Adapter::flowableToFlux)); } @@ -67,7 +65,6 @@ Publisher<T> before(Flux<T> flux) { Flowable.fromPublisher(flux), flux.transform(Flowable::fromPublisher), flux.as(Flowable::fromPublisher), - RxJava2Adapter.fluxToFlowable(flux), flux.transform(RxJava2Adapter::fluxToFlowable)); } @@ -140,7 +137,6 @@ Publisher<T> before(Mono<T> mono) { Flowable.fromPublisher(mono), mono.transform(Flowable::fromPublisher), mono.as(Flowable::fromPublisher), - RxJava2Adapter.monoToFlowable(mono), mono.transform(RxJava2Adapter::monoToFlowable)); } diff --git a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/IdentityConversionCheckTest.java b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/IdentityConversionCheckTest.java new file mode 100644 index 0000000000..f71546197c --- /dev/null +++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/IdentityConversionCheckTest.java @@ -0,0 +1,308 @@ +package tech.picnic.errorprone.bugpatterns; + +import com.google.errorprone.BugCheckerRefactoringTestHelper; +import com.google.errorprone.BugCheckerRefactoringTestHelper.FixChoosers; +import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode; +import com.google.errorprone.CompilationTestHelper; +import org.junit.jupiter.api.Test; + +final class IdentityConversionCheckTest { + private final CompilationTestHelper compilationTestHelper = + CompilationTestHelper.newInstance(IdentityConversionCheck.class, getClass()); + private final BugCheckerRefactoringTestHelper refactoringTestHelper = + BugCheckerRefactoringTestHelper.newInstance(IdentityConversionCheck.class, getClass()); + + @Test + void identification() { + compilationTestHelper + .addSourceLines( + "Foo.java", + "import com.google.common.collect.ImmutableBiMap;", + "import com.google.common.collect.ImmutableList;", + "import com.google.common.collect.ImmutableListMultimap;", + "import com.google.common.collect.ImmutableMap;", + "import com.google.common.collect.ImmutableMultimap;", + "import com.google.common.collect.ImmutableMultiset;", + "import com.google.common.collect.ImmutableRangeMap;", + "import com.google.common.collect.ImmutableRangeSet;", + "import com.google.common.collect.ImmutableSet;", + "import com.google.common.collect.ImmutableSetMultimap;", + "import com.google.common.collect.ImmutableTable;", + "import reactor.adapter.rxjava.RxJava2Adapter;", + "import reactor.core.publisher.Flux;", + "import reactor.core.publisher.Mono;", + "", + "public final class Foo {", + " public void foo() {", + " // BUG: Diagnostic contains:", + " Boolean b1 = Boolean.valueOf(Boolean.FALSE);", + " // BUG: Diagnostic contains:", + " Boolean b2 = Boolean.valueOf(false);", + " // BUG: Diagnostic contains:", + " boolean b3 = Boolean.valueOf(Boolean.FALSE);", + " // BUG: Diagnostic contains:", + " boolean b4 = Boolean.valueOf(false);", + "", + " // BUG: Diagnostic contains:", + " Byte byte1 = Byte.valueOf((Byte) Byte.MIN_VALUE);", + " // BUG: Diagnostic contains:", + " Byte byte2 = Byte.valueOf(Byte.MIN_VALUE);", + " // BUG: Diagnostic contains:", + " byte byte3 = Byte.valueOf((Byte) Byte.MIN_VALUE);", + " // BUG: Diagnostic contains:", + " byte byte4 = Byte.valueOf(Byte.MIN_VALUE);", + "", + " // BUG: Diagnostic contains:", + " Character c1 = Character.valueOf((Character) 'a');", + " // BUG: Diagnostic contains:", + " Character c2 = Character.valueOf('a');", + " // BUG: Diagnostic contains:", + " char c3 = Character.valueOf((Character) 'a');", + " // BUG: Diagnostic contains:", + " char c4 = Character.valueOf('a');", + "", + " // BUG: Diagnostic contains:", + " Double d1 = Double.valueOf((Double) 0.0);", + " // BUG: Diagnostic contains:", + " Double d2 = Double.valueOf(0.0);", + " // BUG: Diagnostic contains:", + " double d3 = Double.valueOf((Double) 0.0);", + " // BUG: Diagnostic contains:", + " double d4 = Double.valueOf(0.0);", + "", + " // BUG: Diagnostic contains:", + " Float f1 = Float.valueOf((Float) 0.0F);", + " // BUG: Diagnostic contains:", + " Float f2 = Float.valueOf(0.0F);", + " // BUG: Diagnostic contains:", + " float f3 = Float.valueOf((Float) 0.0F);", + " // BUG: Diagnostic contains:", + " float f4 = Float.valueOf(0.0F);", + "", + " // BUG: Diagnostic contains:", + " Integer i1 = Integer.valueOf((Integer) 1);", + " // BUG: Diagnostic contains:", + " Integer i2 = Integer.valueOf(1);", + " // BUG: Diagnostic contains:", + " int i3 = Integer.valueOf((Integer) 1);", + " // BUG: Diagnostic contains:", + " int i4 = Integer.valueOf(1);", + "", + " // BUG: Diagnostic contains:", + " Long l1 = Long.valueOf((Long) 1L);", + " // BUG: Diagnostic contains:", + " Long l2 = Long.valueOf(1L);", + " // BUG: Diagnostic contains:", + " long l3 = Long.valueOf((Long) 1L);", + " // BUG: Diagnostic contains:", + " long l4 = Long.valueOf(1L);", + "", + " Long l5 = Long.valueOf((Integer) 1);", + " Long l6 = Long.valueOf(1);", + " // BUG: Diagnostic contains:", + " long l7 = Long.valueOf((Integer) 1);", + " // BUG: Diagnostic contains:", + " long l8 = Long.valueOf(1);", + "", + " // BUG: Diagnostic contains:", + " Short s1 = Short.valueOf((Short) Short.MIN_VALUE);", + " // BUG: Diagnostic contains:", + " Short s2 = Short.valueOf(Short.MIN_VALUE);", + " // BUG: Diagnostic contains:", + " short s3 = Short.valueOf((Short) Short.MIN_VALUE);", + " // BUG: Diagnostic contains:", + " short s4 = Short.valueOf(Short.MIN_VALUE);", + "", + " String str1 = String.valueOf(0);", + " // BUG: Diagnostic contains:", + " String str2 = String.valueOf(\"1\");", + "", + " // BUG: Diagnostic contains:", + " ImmutableBiMap<Object, Object> o1 = ImmutableBiMap.copyOf(ImmutableBiMap.of());", + " // BUG: Diagnostic contains:", + " ImmutableList<Object> o2 = ImmutableList.copyOf(ImmutableList.of());", + " // BUG: Diagnostic contains:", + " ImmutableListMultimap<Object, Object> o3 = ImmutableListMultimap.copyOf(ImmutableListMultimap.of());", + " // BUG: Diagnostic contains:", + " ImmutableMap<Object, Object> o4 = ImmutableMap.copyOf(ImmutableMap.of());", + " // BUG: Diagnostic contains:", + " ImmutableMultimap<Object, Object> o5 = ImmutableMultimap.copyOf(ImmutableMultimap.of());", + " // BUG: Diagnostic contains:", + " ImmutableMultiset<Object> o6 = ImmutableMultiset.copyOf(ImmutableMultiset.of());", + " // BUG: Diagnostic contains:", + " ImmutableRangeMap<String, Object> o7 = ImmutableRangeMap.copyOf(ImmutableRangeMap.of());", + " // BUG: Diagnostic contains:", + " ImmutableRangeSet<String> o8 = ImmutableRangeSet.copyOf(ImmutableRangeSet.of());", + " // BUG: Diagnostic contains:", + " ImmutableSet<Object> o9 = ImmutableSet.copyOf(ImmutableSet.of());", + " // BUG: Diagnostic contains:", + " ImmutableSetMultimap<Object, Object> o10 = ImmutableSetMultimap.copyOf(ImmutableSetMultimap.of());", + " // BUG: Diagnostic contains:", + " ImmutableTable<Object, Object, Object> o11 = ImmutableTable.copyOf(ImmutableTable.of());", + "", + " // BUG: Diagnostic contains:", + " Flux<Integer> flux1 = Flux.just(1).flatMap(e -> RxJava2Adapter.fluxToFlowable(Flux.just(2)));", + " // BUG: Diagnostic contains:", + " Flux<Integer> flux2 = Flux.concat(Flux.just(1));", + " // BUG: Diagnostic contains:", + " Flux<Integer> flux3 = Flux.firstWithSignal(Flux.just(1));", + " // BUG: Diagnostic contains:", + " Flux<Integer> flux4 = Flux.from(Flux.just(1));", + " // BUG: Diagnostic contains:", + " Flux<Integer> flux5 = Flux.merge(Flux.just(1));", + "", + " // BUG: Diagnostic contains:", + " Mono<Integer> m1 = Mono.from(Mono.just(1));", + " // BUG: Diagnostic contains:", + " Mono<Integer> m2 = Mono.fromDirect(Mono.just(1));", + " }", + "}") + .doTest(); + } + + @Test + void replacementFirstSuggestedFix() { + refactoringTestHelper + .setFixChooser(FixChoosers.FIRST) + .addInputLines( + "Foo.java", + "import static org.mockito.Mockito.when;", + "", + "import com.google.common.collect.ImmutableCollection;", + "import com.google.common.collect.ImmutableList;", + "import com.google.common.collect.ImmutableSet;", + "import java.util.Collection;", + "import java.util.ArrayList;", + "import org.reactivestreams.Publisher;", + "import reactor.adapter.rxjava.RxJava2Adapter;", + "import reactor.core.publisher.Flux;", + "import reactor.core.publisher.Mono;", + "", + "public final class Foo {", + " public void foo() {", + " ImmutableSet<Object> set1 = ImmutableSet.copyOf(ImmutableSet.of());", + " ImmutableSet<Object> set2 = ImmutableSet.copyOf(ImmutableList.of());", + "", + " ImmutableCollection<Integer> list1 = ImmutableList.copyOf(ImmutableList.of(1));", + " ImmutableCollection<Integer> list2 = ImmutableList.copyOf(new ArrayList<>(ImmutableList.of(1)));", + "", + " Collection<Integer> c1 = ImmutableSet.copyOf(ImmutableSet.of(1));", + " Collection<Integer> c2 = ImmutableList.copyOf(new ArrayList<>(ImmutableList.of(1)));", + "", + " Flux<Integer> f1 = Flux.just(1).flatMap(e -> RxJava2Adapter.fluxToFlowable(Flux.just(2)));", + " Flux<Integer> f2 = Flux.concat(Flux.just(3));", + " Publisher<Integer> f3 = Flux.firstWithSignal(Flux.just(4));", + " Publisher<Integer> f4 = Flux.from(Flux.just(5));", + " Publisher<Integer> f5 = Flux.merge(Flux.just(6));", + "", + " Mono<Integer> m1 = Mono.from(Mono.just(7));", + " Publisher<Integer> m2 = Mono.fromDirect(Mono.just(8));", + "", + " bar(Flux.concat(Flux.just(9)));", + " bar(Mono.from(Mono.just(10)));", + "", + " Object o1 = ImmutableSet.copyOf(ImmutableList.of());", + " Object o2 = ImmutableSet.copyOf(ImmutableSet.of());", + "", + " when(\"foo\".contains(\"f\"))", + " .thenAnswer(inv-> ImmutableSet.copyOf(ImmutableList.of(1)));", + " }", + "", + " void bar(Publisher<Integer> publisher) {}", + "}") + .addOutputLines( + "Foo.java", + "import static org.mockito.Mockito.when;", + "", + "import com.google.common.collect.ImmutableCollection;", + "import com.google.common.collect.ImmutableList;", + "import com.google.common.collect.ImmutableSet;", + "import java.util.Collection;", + "import java.util.ArrayList;", + "import org.reactivestreams.Publisher;", + "import reactor.adapter.rxjava.RxJava2Adapter;", + "import reactor.core.publisher.Flux;", + "import reactor.core.publisher.Mono;", + "", + "public final class Foo {", + " public void foo() {", + " ImmutableSet<Object> set1 = ImmutableSet.of();", + " ImmutableSet<Object> set2 = ImmutableSet.copyOf(ImmutableList.of());", + "", + " ImmutableCollection<Integer> list1 = ImmutableList.of(1);", + " ImmutableCollection<Integer> list2 = ImmutableList.copyOf(new ArrayList<>(ImmutableList.of(1)));", + "", + " Collection<Integer> c1 = ImmutableSet.of(1);", + " Collection<Integer> c2 = ImmutableList.copyOf(new ArrayList<>(ImmutableList.of(1)));", + "", + " Flux<Integer> f1 = Flux.just(1).flatMap(e -> Flux.just(2));", + " Flux<Integer> f2 = Flux.just(3);", + " Publisher<Integer> f3 = Flux.just(4);", + " Publisher<Integer> f4 = Flux.just(5);", + " Publisher<Integer> f5 = Flux.just(6);", + "", + " Mono<Integer> m1 = Mono.just(7);", + " Publisher<Integer> m2 = Mono.just(8);", + "", + " bar(Flux.just(9));", + " bar(Mono.just(10));", + "", + " Object o1 = ImmutableSet.copyOf(ImmutableList.of());", + " Object o2 = ImmutableSet.of();", + "", + " when(\"foo\".contains(\"f\"))", + " .thenAnswer(inv-> ImmutableSet.copyOf(ImmutableList.of(1)));", + " }", + "", + " void bar(Publisher<Integer> publisher) {}", + "}") + .doTest(TestMode.TEXT_MATCH); + } + + @Test + void replacementSecondSuggestedFix() { + refactoringTestHelper + .setFixChooser(FixChoosers.SECOND) + .addInputLines( + "Foo.java", + "import com.google.common.collect.ImmutableCollection;", + "import com.google.common.collect.ImmutableList;", + "import com.google.common.collect.ImmutableSet;", + "import java.util.ArrayList;", + "import reactor.adapter.rxjava.RxJava2Adapter;", + "import reactor.core.publisher.Flux;", + "import reactor.core.publisher.Mono;", + "", + "public final class Foo {", + " public void foo() {", + " ImmutableSet<Object> set1 = ImmutableSet.copyOf(ImmutableSet.of());", + " ImmutableSet<Object> set2 = ImmutableSet.copyOf(ImmutableList.of());", + "", + " ImmutableCollection<Integer> list1 = ImmutableList.copyOf(ImmutableList.of(1));", + " ImmutableCollection<Integer> list2 = ImmutableList.copyOf(new ArrayList<>(ImmutableList.of(1)));", + " }", + "}") + .addOutputLines( + "Foo.java", + "import com.google.common.collect.ImmutableCollection;", + "import com.google.common.collect.ImmutableList;", + "import com.google.common.collect.ImmutableSet;", + "import java.util.ArrayList;", + "import reactor.adapter.rxjava.RxJava2Adapter;", + "import reactor.core.publisher.Flux;", + "import reactor.core.publisher.Mono;", + "", + "public final class Foo {", + " public void foo() {", + " @SuppressWarnings(\"IdentityConversion\")", + " ImmutableSet<Object> set1 = ImmutableSet.copyOf(ImmutableSet.of());", + " ImmutableSet<Object> set2 = ImmutableSet.copyOf(ImmutableList.of());", + "", + " @SuppressWarnings(\"IdentityConversion\")", + " ImmutableCollection<Integer> list1 = ImmutableList.copyOf(ImmutableList.of(1));", + " ImmutableCollection<Integer> list2 = ImmutableList.copyOf(new ArrayList<>(ImmutableList.of(1)));", + " }", + "}") + .doTest(TestMode.TEXT_MATCH); + } +} diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestInput.java index 8700b72dc6..c1ecb9e63f 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestInput.java @@ -16,19 +16,13 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { ImmutableSet<AbstractByteAssert<?>> testAbstractByteAssertIsEqualTo() { return ImmutableSet.of( assertThat((byte) 0).isCloseTo((byte) 1, offset((byte) 0)), - assertThat((byte) 0).isCloseTo(Byte.valueOf((byte) 1), offset((byte) 0)), - assertThat((byte) 0).isCloseTo((byte) 1, withPercentage(0)), - assertThat((byte) 0).isCloseTo(Byte.valueOf((byte) 1), withPercentage(0)), - assertThat((byte) 0).isEqualTo(Byte.valueOf((byte) 1))); + assertThat((byte) 0).isCloseTo((byte) 1, withPercentage(0))); } ImmutableSet<AbstractByteAssert<?>> testAbstractByteAssertIsNotEqualTo() { return ImmutableSet.of( assertThat((byte) 0).isNotCloseTo((byte) 1, offset((byte) 0)), - assertThat((byte) 0).isNotCloseTo(Byte.valueOf((byte) 1), offset((byte) 0)), - assertThat((byte) 0).isNotCloseTo((byte) 1, withPercentage(0)), - assertThat((byte) 0).isNotCloseTo(Byte.valueOf((byte) 1), withPercentage(0)), - assertThat((byte) 0).isNotEqualTo(Byte.valueOf((byte) 1))); + assertThat((byte) 0).isNotCloseTo((byte) 1, withPercentage(0))); } AbstractByteAssert<?> testAbstractByteAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestOutput.java index 1b15b188b0..b8d588df51 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJByteTemplatesTestOutput.java @@ -15,20 +15,12 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { ImmutableSet<AbstractByteAssert<?>> testAbstractByteAssertIsEqualTo() { return ImmutableSet.of( - assertThat((byte) 0).isEqualTo((byte) 1), - assertThat((byte) 0).isEqualTo((byte) 1), - assertThat((byte) 0).isEqualTo((byte) 1), - assertThat((byte) 0).isEqualTo((byte) 1), - assertThat((byte) 0).isEqualTo((byte) 1)); + assertThat((byte) 0).isEqualTo((byte) 1), assertThat((byte) 0).isEqualTo((byte) 1)); } ImmutableSet<AbstractByteAssert<?>> testAbstractByteAssertIsNotEqualTo() { return ImmutableSet.of( - assertThat((byte) 0).isNotEqualTo((byte) 1), - assertThat((byte) 0).isNotEqualTo((byte) 1), - assertThat((byte) 0).isNotEqualTo((byte) 1), - assertThat((byte) 0).isNotEqualTo((byte) 1), - assertThat((byte) 0).isNotEqualTo((byte) 1)); + assertThat((byte) 0).isNotEqualTo((byte) 1), assertThat((byte) 0).isNotEqualTo((byte) 1)); } AbstractByteAssert<?> testAbstractByteAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestInput.java index ba53ad9efb..488c0649f2 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestInput.java @@ -21,20 +21,13 @@ ImmutableSet<AbstractDoubleAssert<?>> testAbstractDoubleAssertIsCloseToWithOffse ImmutableSet<AbstractDoubleAssert<?>> testAbstractDoubleAssertIsEqualTo() { return ImmutableSet.of( - assertThat(0.0).isCloseTo(1, offset(0.0)), - assertThat(0.0).isCloseTo(Double.valueOf(1), offset(0.0)), - assertThat(0.0).isCloseTo(1, withPercentage(0)), - assertThat(0.0).isCloseTo(Double.valueOf(1), withPercentage(0)), - assertThat(0.0).isEqualTo(Double.valueOf(1))); + assertThat(0.0).isCloseTo(1, offset(0.0)), assertThat(0.0).isCloseTo(1, withPercentage(0))); } ImmutableSet<AbstractDoubleAssert<?>> testAbstractDoubleAssertIsNotEqualTo() { return ImmutableSet.of( assertThat(0.0).isNotCloseTo(1, offset(0.0)), - assertThat(0.0).isNotCloseTo(Double.valueOf(1), offset(0.0)), - assertThat(0.0).isNotCloseTo(1, withPercentage(0)), - assertThat(0.0).isNotCloseTo(Double.valueOf(1), withPercentage(0)), - assertThat(0.0).isNotEqualTo(Double.valueOf(1))); + assertThat(0.0).isNotCloseTo(1, withPercentage(0))); } AbstractDoubleAssert<?> testAbstractDoubleAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestOutput.java index 8aa85ab1c3..cb10589890 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJDoubleTemplatesTestOutput.java @@ -20,21 +20,11 @@ ImmutableSet<AbstractDoubleAssert<?>> testAbstractDoubleAssertIsCloseToWithOffse } ImmutableSet<AbstractDoubleAssert<?>> testAbstractDoubleAssertIsEqualTo() { - return ImmutableSet.of( - assertThat(0.0).isEqualTo(1), - assertThat(0.0).isEqualTo(1), - assertThat(0.0).isEqualTo(1), - assertThat(0.0).isEqualTo(1), - assertThat(0.0).isEqualTo(1)); + return ImmutableSet.of(assertThat(0.0).isEqualTo(1), assertThat(0.0).isEqualTo(1)); } ImmutableSet<AbstractDoubleAssert<?>> testAbstractDoubleAssertIsNotEqualTo() { - return ImmutableSet.of( - assertThat(0.0).isNotEqualTo(1), - assertThat(0.0).isNotEqualTo(1), - assertThat(0.0).isNotEqualTo(1), - assertThat(0.0).isNotEqualTo(1), - assertThat(0.0).isNotEqualTo(1)); + return ImmutableSet.of(assertThat(0.0).isNotEqualTo(1), assertThat(0.0).isNotEqualTo(1)); } AbstractDoubleAssert<?> testAbstractDoubleAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestInput.java index a8c90148db..946687ea21 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestInput.java @@ -21,20 +21,13 @@ ImmutableSet<AbstractFloatAssert<?>> testAbstractFloatAssertIsCloseToWithOffset( ImmutableSet<AbstractFloatAssert<?>> testAbstractFloatAssertIsEqualTo() { return ImmutableSet.of( - assertThat(0F).isCloseTo(1, offset(0F)), - assertThat(0F).isCloseTo(Float.valueOf(1), offset(0F)), - assertThat(0F).isCloseTo(1, withPercentage(0)), - assertThat(0F).isCloseTo(Float.valueOf(1), withPercentage(0)), - assertThat(0F).isEqualTo(Float.valueOf(1))); + assertThat(0F).isCloseTo(1, offset(0F)), assertThat(0F).isCloseTo(1, withPercentage(0))); } ImmutableSet<AbstractFloatAssert<?>> testAbstractFloatAssertIsNotEqualTo() { return ImmutableSet.of( assertThat(0F).isNotCloseTo(1, offset(0F)), - assertThat(0F).isNotCloseTo(Float.valueOf(1), offset(0F)), - assertThat(0F).isNotCloseTo(1, withPercentage(0)), - assertThat(0F).isNotCloseTo(Float.valueOf(1), withPercentage(0)), - assertThat(0F).isNotEqualTo(Float.valueOf(1))); + assertThat(0F).isNotCloseTo(1, withPercentage(0))); } AbstractFloatAssert<?> testAbstractFloatAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestOutput.java index 16f3956cdd..9ff83b5dae 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJFloatTemplatesTestOutput.java @@ -20,21 +20,11 @@ ImmutableSet<AbstractFloatAssert<?>> testAbstractFloatAssertIsCloseToWithOffset( } ImmutableSet<AbstractFloatAssert<?>> testAbstractFloatAssertIsEqualTo() { - return ImmutableSet.of( - assertThat(0F).isEqualTo(1), - assertThat(0F).isEqualTo(1), - assertThat(0F).isEqualTo(1), - assertThat(0F).isEqualTo(1), - assertThat(0F).isEqualTo(1)); + return ImmutableSet.of(assertThat(0F).isEqualTo(1), assertThat(0F).isEqualTo(1)); } ImmutableSet<AbstractFloatAssert<?>> testAbstractFloatAssertIsNotEqualTo() { - return ImmutableSet.of( - assertThat(0F).isNotEqualTo(1), - assertThat(0F).isNotEqualTo(1), - assertThat(0F).isNotEqualTo(1), - assertThat(0F).isNotEqualTo(1), - assertThat(0F).isNotEqualTo(1)); + return ImmutableSet.of(assertThat(0F).isNotEqualTo(1), assertThat(0F).isNotEqualTo(1)); } AbstractFloatAssert<?> testAbstractFloatAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestInput.java index 14826ee3af..2850166d30 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestInput.java @@ -15,20 +15,12 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { ImmutableSet<AbstractIntegerAssert<?>> testAbstractIntegerAssertIsEqualTo() { return ImmutableSet.of( - assertThat(0).isCloseTo(1, offset(0)), - assertThat(0).isCloseTo(Integer.valueOf(1), offset(0)), - assertThat(0).isCloseTo(1, withPercentage(0)), - assertThat(0).isCloseTo(Integer.valueOf(1), withPercentage(0)), - assertThat(0).isEqualTo(Integer.valueOf(1))); + assertThat(0).isCloseTo(1, offset(0)), assertThat(0).isCloseTo(1, withPercentage(0))); } ImmutableSet<AbstractIntegerAssert<?>> testAbstractIntegerAssertIsNotEqualTo() { return ImmutableSet.of( - assertThat(0).isNotCloseTo(1, offset(0)), - assertThat(0).isNotCloseTo(Integer.valueOf(1), offset(0)), - assertThat(0).isNotCloseTo(1, withPercentage(0)), - assertThat(0).isNotCloseTo(Integer.valueOf(1), withPercentage(0)), - assertThat(0).isNotEqualTo(Integer.valueOf(1))); + assertThat(0).isNotCloseTo(1, offset(0)), assertThat(0).isNotCloseTo(1, withPercentage(0))); } AbstractIntegerAssert<?> testAbstractIntegerAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestOutput.java index 557e6f9a42..c937ae8cef 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJIntegerTemplatesTestOutput.java @@ -14,21 +14,11 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { } ImmutableSet<AbstractIntegerAssert<?>> testAbstractIntegerAssertIsEqualTo() { - return ImmutableSet.of( - assertThat(0).isEqualTo(1), - assertThat(0).isEqualTo(1), - assertThat(0).isEqualTo(1), - assertThat(0).isEqualTo(1), - assertThat(0).isEqualTo(1)); + return ImmutableSet.of(assertThat(0).isEqualTo(1), assertThat(0).isEqualTo(1)); } ImmutableSet<AbstractIntegerAssert<?>> testAbstractIntegerAssertIsNotEqualTo() { - return ImmutableSet.of( - assertThat(0).isNotEqualTo(1), - assertThat(0).isNotEqualTo(1), - assertThat(0).isNotEqualTo(1), - assertThat(0).isNotEqualTo(1), - assertThat(0).isNotEqualTo(1)); + return ImmutableSet.of(assertThat(0).isNotEqualTo(1), assertThat(0).isNotEqualTo(1)); } AbstractIntegerAssert<?> testAbstractIntegerAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestInput.java index dcd5b23636..da40158edc 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestInput.java @@ -15,20 +15,13 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { ImmutableSet<AbstractLongAssert<?>> testAbstractLongAssertIsEqualTo() { return ImmutableSet.of( - assertThat(0L).isCloseTo(1, offset(0L)), - assertThat(0L).isCloseTo(Long.valueOf(1), offset(0L)), - assertThat(0L).isCloseTo(1, withPercentage(0)), - assertThat(0L).isCloseTo(Long.valueOf(1), withPercentage(0)), - assertThat(0L).isEqualTo(Long.valueOf(1))); + assertThat(0L).isCloseTo(1, offset(0L)), assertThat(0L).isCloseTo(1, withPercentage(0))); } ImmutableSet<AbstractLongAssert<?>> testAbstractLongAssertIsNotEqualTo() { return ImmutableSet.of( assertThat(0L).isNotCloseTo(1, offset(0L)), - assertThat(0L).isNotCloseTo(Long.valueOf(1), offset(0L)), - assertThat(0L).isNotCloseTo(1, withPercentage(0)), - assertThat(0L).isNotCloseTo(Long.valueOf(1), withPercentage(0)), - assertThat(0L).isNotEqualTo(Long.valueOf(1))); + assertThat(0L).isNotCloseTo(1, withPercentage(0))); } AbstractLongAssert<?> testAbstractLongAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestOutput.java index e237425ef0..d9549d8f6d 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJLongTemplatesTestOutput.java @@ -14,21 +14,11 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { } ImmutableSet<AbstractLongAssert<?>> testAbstractLongAssertIsEqualTo() { - return ImmutableSet.of( - assertThat(0L).isEqualTo(1), - assertThat(0L).isEqualTo(1), - assertThat(0L).isEqualTo(1), - assertThat(0L).isEqualTo(1), - assertThat(0L).isEqualTo(1)); + return ImmutableSet.of(assertThat(0L).isEqualTo(1), assertThat(0L).isEqualTo(1)); } ImmutableSet<AbstractLongAssert<?>> testAbstractLongAssertIsNotEqualTo() { - return ImmutableSet.of( - assertThat(0L).isNotEqualTo(1), - assertThat(0L).isNotEqualTo(1), - assertThat(0L).isNotEqualTo(1), - assertThat(0L).isNotEqualTo(1), - assertThat(0L).isNotEqualTo(1)); + return ImmutableSet.of(assertThat(0L).isNotEqualTo(1), assertThat(0L).isNotEqualTo(1)); } AbstractLongAssert<?> testAbstractLongAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestInput.java index 65e5847207..b111d842e2 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestInput.java @@ -16,19 +16,13 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { ImmutableSet<AbstractShortAssert<?>> testAbstractShortAssertIsEqualTo() { return ImmutableSet.of( assertThat((short) 0).isCloseTo((short) 1, offset((short) 0)), - assertThat((short) 0).isCloseTo(Short.valueOf((short) 1), offset((short) 0)), - assertThat((short) 0).isCloseTo((short) 1, withPercentage(0)), - assertThat((short) 0).isCloseTo(Short.valueOf((short) 1), withPercentage(0)), - assertThat((short) 0).isEqualTo(Short.valueOf((short) 1))); + assertThat((short) 0).isCloseTo((short) 1, withPercentage(0))); } ImmutableSet<AbstractShortAssert<?>> testAbstractShortAssertIsNotEqualTo() { return ImmutableSet.of( assertThat((short) 0).isNotCloseTo((short) 1, offset((short) 0)), - assertThat((short) 0).isNotCloseTo(Short.valueOf((short) 1), offset((short) 0)), - assertThat((short) 0).isNotCloseTo((short) 1, withPercentage(0)), - assertThat((short) 0).isNotCloseTo(Short.valueOf((short) 1), withPercentage(0)), - assertThat((short) 0).isNotEqualTo(Short.valueOf((short) 1))); + assertThat((short) 0).isNotCloseTo((short) 1, withPercentage(0))); } AbstractShortAssert<?> testAbstractShortAssertIsZero() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestOutput.java index 138e79eb7f..db7174fd10 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/AssertJShortTemplatesTestOutput.java @@ -15,18 +15,11 @@ public ImmutableSet<?> elidedTypesAndStaticImports() { ImmutableSet<AbstractShortAssert<?>> testAbstractShortAssertIsEqualTo() { return ImmutableSet.of( - assertThat((short) 0).isEqualTo((short) 1), - assertThat((short) 0).isEqualTo((short) 1), - assertThat((short) 0).isEqualTo((short) 1), - assertThat((short) 0).isEqualTo((short) 1), - assertThat((short) 0).isEqualTo((short) 1)); + assertThat((short) 0).isEqualTo((short) 1), assertThat((short) 0).isEqualTo((short) 1)); } ImmutableSet<AbstractShortAssert<?>> testAbstractShortAssertIsNotEqualTo() { return ImmutableSet.of( - assertThat((short) 0).isNotEqualTo((short) 1), - assertThat((short) 0).isNotEqualTo((short) 1), - assertThat((short) 0).isNotEqualTo((short) 1), assertThat((short) 0).isNotEqualTo((short) 1), assertThat((short) 0).isNotEqualTo((short) 1)); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestInput.java index 5c92c169fd..cc9f374094 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestInput.java @@ -113,8 +113,4 @@ ImmutableListMultimap<String, Integer> testTransformMultimapValuesToImmutableLis flatteningToImmutableListMultimap( Map.Entry::getKey, e -> e.getValue().stream().map(Math::toIntExact)))); } - - ImmutableListMultimap<String, Integer> testImmutableListMultimapCopyOfImmutableListMultimap() { - return ImmutableListMultimap.copyOf(ImmutableListMultimap.of("foo", 1)); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestOutput.java index f9ccde87e5..a1825c9070 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableListMultimapTemplatesTestOutput.java @@ -89,8 +89,4 @@ ImmutableListMultimap<String, Integer> testTransformMultimapValuesToImmutableLis ImmutableListMultimap.copyOf( Multimaps.transformValues(TreeMultimap.<String, Long>create(), Math::toIntExact))); } - - ImmutableListMultimap<String, Integer> testImmutableListMultimapCopyOfImmutableListMultimap() { - return ImmutableListMultimap.of("foo", 1); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java index 24b3dccb85..d119cd9763 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestInput.java @@ -86,8 +86,4 @@ ImmutableSet<ImmutableMap<String, Integer>> testTransformMapValuesToImmutableMap ImmutableMap.of("bar", 2L).keySet(), k -> Math.toIntExact(ImmutableMap.of("bar", 2L).get(k)))); } - - ImmutableMap<String, Integer> testImmutableMapCopyOfImmutableMap() { - return ImmutableMap.copyOf(ImmutableMap.of("foo", 1)); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java index dce623468a..e1638de70e 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMapTemplatesTestOutput.java @@ -72,8 +72,4 @@ ImmutableSet<ImmutableMap<String, Integer>> testTransformMapValuesToImmutableMap ImmutableMap.copyOf( Maps.transformValues(ImmutableMap.of("bar", 2L), v -> Math.toIntExact(v)))); } - - ImmutableMap<String, Integer> testImmutableMapCopyOfImmutableMap() { - return ImmutableMap.of("foo", 1); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestInput.java index d48a3b67ad..eb08577f52 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestInput.java @@ -44,8 +44,4 @@ ImmutableSet<ImmutableMultiset<Integer>> testStreamToImmutableMultiset() { ImmutableMultiset.copyOf(Stream.of(1).iterator()), Stream.of(2).collect(collectingAndThen(toList(), ImmutableMultiset::copyOf))); } - - ImmutableMultiset<Integer> testImmutableMultisetCopyOfImmutableMultiset() { - return ImmutableMultiset.copyOf(ImmutableMultiset.of(1, 2)); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestOutput.java index 143f268caa..56da87e4be 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableMultisetTemplatesTestOutput.java @@ -41,8 +41,4 @@ ImmutableSet<ImmutableMultiset<Integer>> testStreamToImmutableMultiset() { return ImmutableSet.of( Stream.of(1).collect(toImmutableMultiset()), Stream.of(2).collect(toImmutableMultiset())); } - - ImmutableMultiset<Integer> testImmutableMultisetCopyOfImmutableMultiset() { - return ImmutableMultiset.of(1, 2); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestInput.java index 779541d5c3..270166011e 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestInput.java @@ -91,8 +91,4 @@ ImmutableSetMultimap<String, Integer> testTransformMultimapValuesToImmutableSetM flatteningToImmutableSetMultimap( Map.Entry::getKey, e -> e.getValue().stream().map(Math::toIntExact)))); } - - ImmutableSetMultimap<String, Integer> testImmutableSetMultimapCopyOfImmutableSetMultimap() { - return ImmutableSetMultimap.copyOf(ImmutableSetMultimap.of("foo", 1)); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestOutput.java index a40daadd0d..bf3360c5d4 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetMultimapTemplatesTestOutput.java @@ -72,8 +72,4 @@ ImmutableSetMultimap<String, Integer> testTransformMultimapValuesToImmutableSetM ImmutableSetMultimap.copyOf( Multimaps.transformValues(TreeMultimap.<String, Long>create(), Math::toIntExact))); } - - ImmutableSetMultimap<String, Integer> testImmutableSetMultimapCopyOfImmutableSetMultimap() { - return ImmutableSetMultimap.of("foo", 1); - } } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java index d8d9c7cd2c..4fd3650179 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestInput.java @@ -59,10 +59,6 @@ ImmutableSet<ImmutableSet<Integer>> testStreamToImmutableSet() { Stream.of(4).collect(collectingAndThen(toSet(), ImmutableSet::copyOf))); } - ImmutableSet<Integer> testImmutableSetCopyOfImmutableSet() { - return ImmutableSet.copyOf(ImmutableSet.of(1, 2)); - } - ImmutableSet<Integer> testImmutableSetCopyOfSetView() { return ImmutableSet.copyOf(Sets.difference(ImmutableSet.of(1), ImmutableSet.of(2))); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java index a8d8334b0e..b23aac8871 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ImmutableSetTemplatesTestOutput.java @@ -58,10 +58,6 @@ ImmutableSet<ImmutableSet<Integer>> testStreamToImmutableSet() { Stream.of(4).collect(toImmutableSet())); } - ImmutableSet<Integer> testImmutableSetCopyOfImmutableSet() { - return ImmutableSet.of(1, 2); - } - ImmutableSet<Integer> testImmutableSetCopyOfSetView() { return Sets.difference(ImmutableSet.of(1), ImmutableSet.of(2)).immutableCopy(); } diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestInput.java index add57fb20c..1b37353ff5 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestInput.java @@ -63,10 +63,6 @@ Flux<String> testMonoFlux() { return Flux.concat(Mono.just("foo")); } - Flux<String> testFluxIdentity() { - return Flux.concat(Flux.just("foo")); - } - ImmutableSet<Mono<Optional<String>>> testMonoCollectToOptional() { return ImmutableSet.of( Mono.just("foo").map(Optional::of).defaultIfEmpty(Optional.empty()), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestOutput.java index 3dcff32c5f..31cb488593 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/ReactorTemplatesTestOutput.java @@ -63,10 +63,6 @@ Flux<String> testMonoFlux() { return Mono.just("foo").flux(); } - Flux<String> testFluxIdentity() { - return Flux.just("foo"); - } - ImmutableSet<Mono<Optional<String>>> testMonoCollectToOptional() { return ImmutableSet.of( Mono.just("foo").flux().collect(toOptional()), diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestInput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestInput.java index fcc5e889b0..55c824c20a 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestInput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestInput.java @@ -25,13 +25,11 @@ ImmutableSet<Publisher<Integer>> testFlowableToFlux() { // seventh parameter onwards. return ImmutableSet.copyOf( Arrays.asList( - Flux.from(Flowable.just(1)), - Flowable.just(2).compose(Flux::from), - Flowable.just(3).to(Flux::from), - Flowable.just(4).as(Flux::from), - RxJava2Adapter.flowableToFlux(Flowable.just(5)), - Flowable.just(6).compose(RxJava2Adapter::flowableToFlux), - Flowable.just(7).<Publisher<Integer>>to(RxJava2Adapter::flowableToFlux))); + Flowable.just(1).compose(Flux::from), + Flowable.just(2).to(Flux::from), + Flowable.just(3).as(Flux::from), + Flowable.just(4).compose(RxJava2Adapter::flowableToFlux), + Flowable.just(5).<Publisher<Integer>>to(RxJava2Adapter::flowableToFlux))); } ImmutableSet<Publisher<String>> testFluxToFlowable() { @@ -39,8 +37,7 @@ ImmutableSet<Publisher<String>> testFluxToFlowable() { Flowable.fromPublisher(Flux.just("foo")), Flux.just("bar").transform(Flowable::fromPublisher), Flux.just("baz").as(Flowable::fromPublisher), - RxJava2Adapter.fluxToFlowable(Flux.just("qux")), - Flux.just("quux").transform(RxJava2Adapter::fluxToFlowable)); + Flux.just("qux").transform(RxJava2Adapter::fluxToFlowable)); } ImmutableSet<Observable<Integer>> testFluxToObservable() { @@ -68,8 +65,7 @@ ImmutableSet<Publisher<Integer>> testMonoToFlowable() { Flowable.fromPublisher(Mono.just(1)), Mono.just(2).transform(Flowable::fromPublisher), Mono.just(3).as(Flowable::fromPublisher), - RxJava2Adapter.monoToFlowable(Mono.just(4)), - Mono.just(5).transform(RxJava2Adapter::monoToFlowable)); + Mono.just(4).transform(RxJava2Adapter::monoToFlowable)); } Maybe<String> testMonoToMaybe() { diff --git a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestOutput.java b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestOutput.java index 49fec4d182..8c38f368b4 100644 --- a/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestOutput.java +++ b/error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJava2AdapterTemplatesTestOutput.java @@ -29,9 +29,7 @@ ImmutableSet<Publisher<Integer>> testFlowableToFlux() { Flowable.just(2).as(RxJava2Adapter::flowableToFlux), Flowable.just(3).as(RxJava2Adapter::flowableToFlux), Flowable.just(4).as(RxJava2Adapter::flowableToFlux), - Flowable.just(5).as(RxJava2Adapter::flowableToFlux), - Flowable.just(6).as(RxJava2Adapter::flowableToFlux), - Flowable.just(7).as(RxJava2Adapter::flowableToFlux))); + Flowable.just(5).as(RxJava2Adapter::flowableToFlux))); } ImmutableSet<Publisher<String>> testFluxToFlowable() { @@ -39,8 +37,7 @@ ImmutableSet<Publisher<String>> testFluxToFlowable() { Flux.just("foo").as(RxJava2Adapter::fluxToFlowable), Flux.just("bar").as(RxJava2Adapter::fluxToFlowable), Flux.just("baz").as(RxJava2Adapter::fluxToFlowable), - Flux.just("qux").as(RxJava2Adapter::fluxToFlowable), - Flux.just("quux").as(RxJava2Adapter::fluxToFlowable)); + Flux.just("qux").as(RxJava2Adapter::fluxToFlowable)); } ImmutableSet<Observable<Integer>> testFluxToObservable() { @@ -68,8 +65,7 @@ ImmutableSet<Publisher<Integer>> testMonoToFlowable() { Mono.just(1).as(RxJava2Adapter::monoToFlowable), Mono.just(2).as(RxJava2Adapter::monoToFlowable), Mono.just(3).as(RxJava2Adapter::monoToFlowable), - Mono.just(4).as(RxJava2Adapter::monoToFlowable), - Mono.just(5).as(RxJava2Adapter::monoToFlowable)); + Mono.just(4).as(RxJava2Adapter::monoToFlowable)); } Maybe<String> testMonoToMaybe() {