jlengrand/error-prone-support
1
0
Fork 0
mirror of https://github.com/jlengrand/error-prone-support.git synced 2026-03-10 08:11:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add many templates and tiny improvements. Note: tests are broken now because building against picnic-error-prone

Browse Source
This commit is contained in:
Rick Ossendrijver
2021-09-11 12:01:42 +02:00
parent 773eeae53b
commit e66e2be8ff
13 changed files with 214 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaCompletableToReactorTemplates.java
View File

@@ -9,6 +9,8 @@ import com.google.errorprone.refaster.annotation.BeforeTemplate;
import com.google.errorprone.refaster.annotation.UseImportPolicy;
import io.reactivex.Completable;
import io.reactivex.CompletableSource;
import io.reactivex.Single;
import io.reactivex.SingleSource;
import io.reactivex.functions.Action;
import java.util.concurrent.Callable;
import java.util.function.Supplier;
@@ -141,6 +143,23 @@ final class RxJavaCompletableToReactorTemplates {
// XXX: public final Observable andThen(ObservableSource)
// XXX: public final Flowable andThen(Publisher)
// XXX: public final Single andThen(SingleSource)
// XXX: Verify this case
static final class CompletableAndThenSingle<T> {
@BeforeTemplate
Single<T> before(Completable completable, SingleSource<T> source) {
return completable.andThen(source);
}
@AfterTemplate
Single<T> after(Completable completable, SingleSource<T> source) {
return completable
.as(RxJava2Adapter::completableToMono)
.then(Single.wrap(source).as(RxJava2Adapter::singleToMono))
.as(RxJava2Adapter::monoToSingle);
}
}
// XXX: public final Object as(CompletableConverter)
// XXX: public final void blockingAwait()
// XXX: public final boolean blockingAwait(long,TimeUnit)

14
error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaFlowableToReactorTemplates.java
View File

@@ -137,7 +137,6 @@ final class RxJavaFlowableToReactorTemplates {
}
}
// XXX: Use `CanBeCoercedTo`.
static final class FlowableErrorCallable<T> {
@BeforeTemplate
Flowable<T> before(Callable<? extends Throwable> throwable) {
@@ -145,11 +144,14 @@ final class RxJavaFlowableToReactorTemplates {
}
@AfterTemplate
Flowable<T> after(Supplier<? extends Throwable> throwable) {
return RxJava2Adapter.fluxToFlowable(Flux.error(throwable));
Flowable<T> after(Callable<? extends Throwable> throwable) {
return RxJava2Adapter.fluxToFlowable(
Flux.error(RxJava2ReactorMigrationUtil.callableAsSupplier(throwable)));
}
}
// XXX: Thing to remove the callableAssupplier for this.
static final class FlowableErrorThrowable<T> {
@BeforeTemplate
Flowable<T> before(Throwable throwable) {
@@ -372,6 +374,7 @@ final class RxJavaFlowableToReactorTemplates {
}
}
// XXX: MOVE?
static final class BiFunctionRemoveUtil<T, U, R> {
@BeforeTemplate
java.util.function.BiFunction<? super T, ? super U, ? extends R> before(
@@ -729,10 +732,9 @@ final class RxJavaFlowableToReactorTemplates {
// XXX: final Flowable lift(FlowableOperator)
// XXX: final Flowable limit(long)
// XXX: `Refaster.canBeCoercedTo(...)`.
static final class FlowableMap<I, T extends I, O> {
@BeforeTemplate
Flowable<O> before(Flowable<T> flowable, Function<I, O> function) {
Flowable<O> before(Flowable<T> flowable, @CanTransformToTargetType Function<I, O> function) {
return flowable.map(function);
}
@@ -750,7 +752,7 @@ final class RxJavaFlowableToReactorTemplates {
// XXX: final Flowable mergeWith(MaybeSource)
// XXX: final Flowable mergeWith(Publisher)
// XXX: Check whethter the `toFlowable()` is correct.
// XXX: Check whether the `toFlowable()` is correct.
static final class FlowableMergeWith<T> {
@BeforeTemplate

78
error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaMaybeToReactorTemplates.java
View File

@@ -14,6 +14,7 @@ import io.reactivex.Flowable;
import io.reactivex.Maybe;
import io.reactivex.MaybeSource;
import io.reactivex.Single;
import io.reactivex.SingleSource;
import io.reactivex.functions.Action;
import io.reactivex.functions.Function;
import java.util.Arrays;
@@ -98,6 +99,23 @@ final class RxJavaMaybeToReactorTemplates {
* tagId.map(Maybe::just).orElseGet(Maybe::empty)) - .flatMapSingleElement(this::getTagById) -
* .ignoreElement()); + .flatMapSingleElement(this::getTagById).as(RxJava2Adapter::maybeToMono).
*/
/// XXX: Check this one is required for case above.
abstract static class MaybeDeferFirst<T> {
@Placeholder
abstract Maybe<T> maybeProducer();
@BeforeTemplate
Maybe<T> before() {
return Maybe.defer(() -> maybeProducer());
}
@AfterTemplate
Maybe<T> after() {
return Mono.defer(() -> maybeProducer().as(RxJava2Adapter::maybeToMono))
.as(RxJava2Adapter::monoToMaybe);
}
}
abstract static class MaybeDefer<T> {
@Placeholder
abstract Maybe<T> maybeProducer();
@@ -125,7 +143,6 @@ final class RxJavaMaybeToReactorTemplates {
}
}
// XXX: Use `CanBeCoercedTo`.
static final class MaybeErrorCallable<T> {
@BeforeTemplate
Maybe<T> before(Callable<? extends Throwable> throwable) {
@@ -133,8 +150,10 @@ final class RxJavaMaybeToReactorTemplates {
}
@AfterTemplate
Maybe<T> after(Supplier<? extends Throwable> throwable) {
return RxJava2Adapter.monoToMaybe(Mono.error(throwable));
Maybe<T> after(Callable<? extends Throwable> throwable) {
return RxJava2Adapter.monoToMaybe(
Mono.error(
RxJavaToReactorTemplates.RxJava2ReactorMigrationUtil.callableAsSupplier(throwable)));
}
}
@@ -196,8 +215,36 @@ final class RxJavaMaybeToReactorTemplates {
// XXX: public static Maybe fromFuture(Future,long,TimeUnit)
// XXX: public static Maybe fromRunnable(Runnable)
static final class MaybeFromRunnable<T> {
@BeforeTemplate
Maybe<T> before(Runnable runnable) {
Maybe.fromRunnable(() -> {
int i = 1 + 1;
});
return Maybe.fromRunnable(runnable);
}
@AfterTemplate
Maybe<T> after(Runnable runnable) {
return RxJava2Adapter.monoToMaybe(Mono.fromRunnable(runnable));
}
}
// XXX: public static Maybe fromSingle(SingleSource)
// XXX: public static Maybe just(Object)
static final class MaybeJust<T> {
@BeforeTemplate
Maybe<T> before(T item) {
return Maybe.just(item);
}
@AfterTemplate
Maybe<T> after(T item) {
return RxJava2Adapter.monoToMaybe(Mono.just(item));
}
}
// XXX: public static Flowable merge(Iterable)
// XXX: public static Maybe merge(MaybeSource)
// XXX: public static Flowable merge(MaybeSource,MaybeSource)
@@ -451,19 +498,34 @@ final class RxJavaMaybeToReactorTemplates {
// XXX: public final void subscribe(MaybeObserver)
// XXX: public final Maybe subscribeOn(Scheduler)
// XXX: public final MaybeObserver subscribeWith(MaybeObserver)
// XXX: public final Maybe switchIfEmpty(MaybeSource)
// XXX: Make test
static final class MaybeSourceSwitchIfEmpty<S, T extends S> {
@BeforeTemplate
Maybe<S> before(Maybe<S> maybe, MaybeSource<T> maybeSource) {
return maybe.switchIfEmpty(maybeSource);
}
@AfterTemplate
Maybe<S> after(Maybe<S> maybe, MaybeSource<T> maybeSource) {
return maybe
.as(RxJava2Adapter::maybeToMono)
.switchIfEmpty(RxJava2Adapter.maybeToMono(Maybe.wrap(maybeSource)))
.as(RxJava2Adapter::monoToMaybe);
}
}
static final class MaybeSwitchIfEmpty<S, T extends S> {
@BeforeTemplate
Single<S> before(Maybe<S> maybe, Single<T> single) {
Single<S> before(Maybe<S> maybe, SingleSource<T> single) {
return maybe.switchIfEmpty(single);
}
@AfterTemplate
Single<S> after(Maybe<S> maybe, Single<T> single) {
Single<S> after(Maybe<S> maybe, SingleSource<T> single) {
return maybe
.as(RxJava2Adapter::maybeToMono)
.switchIfEmpty(single.as(RxJava2Adapter::singleToMono))
.switchIfEmpty(RxJava2Adapter.singleToMono(Single.wrap(single)))
.as(RxJava2Adapter::monoToSingle);
}
}

23
error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaSingleToReactorTemplates.java
View File

@@ -44,8 +44,8 @@ final class RxJavaSingleToReactorTemplates {
}
@AfterTemplate
Single<T> after(Supplier<? extends Throwable> throwable) {
return RxJava2Adapter.monoToSingle(Mono.error(throwable));
Single<T> after(Callable<? extends Throwable> throwable) {
return RxJava2Adapter.monoToSingle(Mono.error(RxJavaToReactorTemplates.RxJava2ReactorMigrationUtil.callableAsSupplier(throwable)));
}
}
@@ -61,7 +61,6 @@ final class RxJavaSingleToReactorTemplates {
}
}
// XXX: Can be coerced to.
static final class SingleFromCallable<T> {
@BeforeTemplate
Single<T> before(Callable<? extends T> callable) {
@@ -91,7 +90,7 @@ final class RxJavaSingleToReactorTemplates {
@AfterTemplate
Single<T> after(T item) {
return Mono.just(item).as(RxJava2Adapter::monoToSingle);
return RxJava2Adapter.monoToSingle(Mono.just(item));
}
}
@@ -113,7 +112,19 @@ final class RxJavaSingleToReactorTemplates {
// XXX: public static Single unsafeCreate(SingleSource)
// XXX: public static Single using(Callable,Function,Consumer)
// XXX: public static Single using(Callable,Function,Consumer,boolean)
// XXX: public static Single wrap(SingleSource) --> Required
static final class SingleWrap<T> {
@BeforeTemplate
Single<T> before(Single<T> single) {
return Single.wrap(single);
}
@AfterTemplate
Single<T> after(Single<T> single) {
return single;
}
}
// XXX: public static Single zip(Iterable,Function)
// XXX: public static Single zip(SingleSource,SingleSource,BiFunction)
// XXX: public static Single zip(SingleSource,SingleSource,SingleSource,Function3)
@@ -159,7 +170,7 @@ final class RxJavaSingleToReactorTemplates {
// XXX: public final Single doOnSuccess(Consumer) --> Required
// XXX: public final Single doOnTerminate(Action)
// XXX: `function` type change; look into `Refaster.canBeCoercedTo(...)`.
// XXX: `function` type change; look into `Refaster.canBeCoercedTo(...)`. or to JdkPredicate.
static final class SingleFilter<S, T extends S> {
@BeforeTemplate
Maybe<T> before(Single<T> single, Predicate<S> predicate) {

47
error-prone-contrib/src/main/java/tech/picnic/errorprone/refastertemplates/RxJavaToReactorTemplates.java
View File

@@ -3,8 +3,10 @@ package tech.picnic.errorprone.refastertemplates;
import com.google.errorprone.refaster.Refaster;
import com.google.errorprone.refaster.annotation.AfterTemplate;
import com.google.errorprone.refaster.annotation.BeforeTemplate;
import com.google.errorprone.refaster.annotation.CanTransformToTargetType;
import io.reactivex.BackpressureStrategy;
import io.reactivex.functions.Action;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Function;
import java.util.concurrent.Callable;
import java.util.function.Supplier;
@@ -22,6 +24,7 @@ public final class RxJavaToReactorTemplates {
Flux<T> before(Flux<T> flux, BackpressureStrategy strategy) {
return Refaster.anyOf(
RxJava2Adapter.fluxToFlowable(flux).as(RxJava2Adapter::flowableToFlux),
RxJava2Adapter.flowableToFlux(RxJava2Adapter.fluxToFlowable(flux)),
flux.as(RxJava2Adapter::fluxToObservable)
.toFlowable(strategy)
.as(RxJava2Adapter::flowableToFlux),
@@ -43,7 +46,8 @@ public final class RxJavaToReactorTemplates {
return Refaster.anyOf(
RxJava2Adapter.monoToCompletable(mono).as(RxJava2Adapter::completableToMono),
mono.as(RxJava2Adapter::monoToCompletable).as(RxJava2Adapter::completableToMono),
RxJava2Adapter.completableToMono(RxJava2Adapter.monoToCompletable(mono)));
RxJava2Adapter.completableToMono(RxJava2Adapter.monoToCompletable(mono)),
RxJava2Adapter.completableToMono(mono.as(RxJava2Adapter::monoToCompletable)));
}
@BeforeTemplate
@@ -51,9 +55,11 @@ public final class RxJavaToReactorTemplates {
return Refaster.anyOf(
RxJava2Adapter.monoToMaybe(mono).as(RxJava2Adapter::maybeToMono),
RxJava2Adapter.maybeToMono(RxJava2Adapter.monoToMaybe(mono)),
RxJava2Adapter.maybeToMono(mono.as(RxJava2Adapter::monoToMaybe)),
mono.as(RxJava2Adapter::monoToMaybe).as(RxJava2Adapter::maybeToMono),
RxJava2Adapter.monoToSingle(mono).as(RxJava2Adapter::singleToMono),
RxJava2Adapter.singleToMono(RxJava2Adapter.monoToSingle(mono)),
RxJava2Adapter.singleToMono(mono.as(RxJava2Adapter::monoToSingle)),
mono.as(RxJava2Adapter::monoToSingle).as(RxJava2Adapter::singleToMono));
}
@@ -63,18 +69,46 @@ public final class RxJavaToReactorTemplates {
}
}
static final class RemoveRedundantCast<T> {
// XXX: Does this make sense?
// This is what we want to fix: Mono.error(RxJava2ReactorMigrationUtil.callableAsSupplier(() ->
// new ItemNotFoundException("Banner", bannerId))));
static final class MonoErrorCallableSupplierUtil<T> {
@BeforeTemplate
T before(T object) {
return (T) object;
Mono<T> before(Callable<? extends Throwable> callable) {
return Mono.error(RxJava2ReactorMigrationUtil.callableAsSupplier(callable));
}
@AfterTemplate
T after(T object) {
return object;
Mono<T> after(Supplier<? extends Throwable> callable) {
return Mono.error(callable);
}
}
static final class RemoveUtilCallable<T> {
@BeforeTemplate
Supplier<T> before(@CanTransformToTargetType Callable<T> callable) {
return RxJava2ReactorMigrationUtil.callableAsSupplier(callable);
}
@AfterTemplate
Supplier<T> before(Supplier<T> callable) {
return callable;
}
}
// This triggerred something in PRP what should not be changed.
// static final class RemoveRedundantCast<T> {
// @BeforeTemplate
// T before(T object) {
// return (T) object;
// }
//
// @AfterTemplate
// T after(T object) {
// return object;
// }
// }
// XXX: Use `CanBeCoercedTo`
@SuppressWarnings("NoFunctionalReturnType")
static final class UnnecessaryConversion<I, O> {
@@ -196,6 +230,7 @@ public final class RxJavaToReactorTemplates {
/**
* XXX
*
* @param action XXX
* @return XXX
*/

7
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaFlowableToReactorTemplatesTestOutput.java
View File

@@ -46,9 +46,10 @@ final class RxJavaFlowableToReactorTemplatesTest implements RefasterTemplateTest
Flowable<Object> testFlowableErrorCallable() {
return RxJava2Adapter.fluxToFlowable(
Flux.error(
() -> {
throw new IllegalStateException();
}));
RxJavaToReactorTemplates.RxJava2ReactorMigrationUtil.callableAsSupplier(
() -> {
throw new IllegalStateException();
})));
}
Flowable<Integer> testFlowableFromArray() {

10
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestInput.java
View File

@@ -61,6 +61,16 @@ final class RxJavaMaybeToReactorTemplatesTest implements RefasterTemplateTestCas
return Maybe.fromFuture(new CompletableFuture<>());
}
Maybe<Integer> testMaybeFromRunnable() {
return Maybe.fromRunnable(() -> {
int i = 1 + 1;
});
}
Maybe<Integer> testMaybeJust() {
return Maybe.just(1);
}
Maybe<Integer> testMaybeWrap() {
return Maybe.wrap(Maybe.just(1));
}

12
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaMaybeToReactorTemplatesTestOutput.java
View File

@@ -72,6 +72,18 @@ final class RxJavaMaybeToReactorTemplatesTest implements RefasterTemplateTestCas
return RxJava2Adapter.monoToMaybe(Mono.fromFuture(new CompletableFuture<>()));
}
Maybe<Integer> testMaybeFromRunnable() {
return RxJava2Adapter.monoToMaybe(
Mono.fromRunnable(
() -> {
int i = 1 + 1;
}));
}
Maybe<Integer> testMaybeJust() {
return RxJava2Adapter.monoToMaybe(Mono.just(1));
}
Maybe<Integer> testMaybeWrap() {
return Maybe.just(1);
}

4
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestInput.java
View File

@@ -26,6 +26,10 @@ final class RxJavaSingleToReactorTemplatesTest implements RefasterTemplateTestCa
return Single.just(1);
}
Single<Integer> testSingleWrap() {
return Single.wrap(Single.just(1));
}
Maybe<Integer> testSingleFilter() {
return Single.just(1).filter(i -> i > 2);
}

13
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaSingleToReactorTemplatesTestOutput.java
View File

@@ -17,9 +17,10 @@ final class RxJavaSingleToReactorTemplatesTest implements RefasterTemplateTestCa
Single<Object> testSingleErrorCallable() {
return RxJava2Adapter.monoToSingle(
Mono.error(
() -> {
throw new IllegalStateException();
}));
RxJavaToReactorTemplates.RxJava2ReactorMigrationUtil.callableAsSupplier(
() -> {
throw new IllegalStateException();
})));
}
Single<Integer> testSingleFromCallable() {
@@ -29,7 +30,11 @@ final class RxJavaSingleToReactorTemplatesTest implements RefasterTemplateTestCa
}
Single<Integer> testSingleJust() {
return Mono.just(1).as(RxJava2Adapter::monoToSingle);
return RxJava2Adapter.monoToSingle(Mono.just(1));
}
Single<Integer> testSingleWrap() {
return Single.just(1);
}
Maybe<Integer> testSingleFilter() {

9
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaToReactorTemplatesTestInput.java
View File

@@ -7,6 +7,7 @@ import io.reactivex.Single;
import reactor.adapter.rxjava.RxJava2Adapter;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import tech.picnic.errorprone.refastertemplates.RxJavaToReactorTemplates;
final class RxJavaToReactorTemplatesTest implements RefasterTemplateTestCase {
@@ -39,4 +40,12 @@ final class RxJavaToReactorTemplatesTest implements RefasterTemplateTestCase {
return Mono.just(3).as(RxJava2Adapter::monoToMaybe).as(RxJava2Adapter::maybeToMono);
}
Mono<Integer> testMonoErrorCallableSupplierUtil() {
return Mono.just(1)
.switchIfEmpty(
Mono.error(
RxJavaToReactorTemplates.RxJava2ReactorMigrationUtil.callableAsSupplier(
() -> new IllegalStateException())));
}
}

4
error-prone-contrib/src/test/resources/tech/picnic/errorprone/bugpatterns/RxJavaToReactorTemplatesTestOutput.java
View File

@@ -35,4 +35,8 @@ final class RxJavaToReactorTemplatesTest implements RefasterTemplateTestCase {
return Mono.just(3);
}
Mono<Integer> testMonoErrorCallableSupplierUtil() {
return Mono.just(1).switchIfEmpty(Mono.error(() -> new IllegalStateException()));
}
}

14
pom.xml
View File

@@ -1152,13 +1152,13 @@
fork, some other dependencies depend on the official (i.e.,
non-forked) `error_prone_annotations`. Here we fix which
version is pulled in. -->
<dependencies>
<dependency>
<groupId>com.google.errorprone</groupId>
<artifactId>error_prone_annotations</artifactId>
<version>${version.error-prone-orig}</version>
</dependency>
</dependencies>
<!-- <dependencies>-->
<!-- <dependency>-->
<!-- <groupId>com.google.errorprone</groupId>-->
<!-- <artifactId>error_prone_annotations</artifactId>-->
<!-- <version>${version.error-prone-orig}</version>-->
<!-- </dependency>-->
<!-- </dependencies>-->
</dependencyManagement>
</profile>
<profile>