Skip to main content

8.80.0 release (2026-04-21)

Total recipe count: 4332

info

This changelog only shows what recipes have been added, removed, or changed. OpenRewrite may do releases that do not include these types of changes. To see these changes, please go to the releases page.

New Recipes​

static final class AssertThatStreamContainsAnyOfVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsAnyOf")
    IterableAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsAnyOf")
    AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Collection<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsAnyOf")
    ListAssert<T> before3(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsAnyOf(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "ObjectEnumerableContainsOneElement")
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).containsAnyOf(elements);
    }
}

.

static final class AssertThatStreamContainsExactlyInAnyOrderVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsExactlyInAnyOrder")
    ListAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsExactlyInAnyOrder")
    AbstractCollectionAssert<?, ?, T, ?> before2(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Multiset<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactlyInAnyOrder(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "ObjectEnumerableContainsExactlyOneElement")
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).containsExactlyInAnyOrder(elements);
    }
}

.

static final class AssertThatStreamContainsExactlyVarargs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsExactly")
    ListAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsExactly(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).containsExactly(elements);
    }
}

.

static final class AssertThatStreamContainsOnlyVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsOnly")
    IterableAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsOnly")
    AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Collection<T>> collector) {
        return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsOnly")
    ListAssert<T> before3(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsOnly(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).containsOnly(elements);
    }
}

.

static final class AssertThatStreamContainsSequenceVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsSequence")
    ListAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsSequence(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "ObjectEnumerableContainsOneElement")
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).containsSequence(elements);
    }
}

.

static final class AssertThatStreamContainsSubsequenceVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContainsSubsequence")
    ListAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).containsSubsequence(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "ObjectEnumerableContainsOneElement")
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).containsSubsequence(elements);
    }
}

.

static final class AssertThatStreamContainsVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContains")
    IterableAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContains")
    AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Collection<T>> collector) {
        return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamContains")
    ListAssert<T> before3(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).contains(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).contains(elements);
    }
}

.

static final class AssertThatStreamDoesNotContainSequenceVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamDoesNotContainSequence")
    ListAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContainSequence(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @SuppressWarnings(value = "ObjectEnumerableDoesNotContainOneElement")
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).doesNotContainSequence(elements);
    }
}

.

static final class AssertThatStreamDoesNotContainVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamDoesNotContain")
    IterableAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamDoesNotContain")
    AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Collection<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamDoesNotContain")
    ListAssert<T> before3(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).doesNotContain(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).doesNotContain(elements);
    }
}

.

static final class AssertThatStreamIsSubsetOfVarArgs<S, T extends S, U extends T> {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamIsSubsetOf")
    IterableAssert<T> before(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Iterable<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamIsSubsetOf")
    AbstractCollectionAssert<?, Collection<? extends T>, T, ObjectAssert<T>> before2(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends Collection<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
    }
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatStreamIsSubsetOf")
    ListAssert<T> before3(Stream<S> stream, @Repeated
    U elements, Collector<S, ?, ? extends List<T>> collector) {
        return assertThat(stream.collect(collector)).isSubsetOf(Refaster.asVarargs(elements));
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    ListAssert<S> after(Stream<S> stream, @Repeated
    U elements) {
        return assertThat(stream).isSubsetOf(elements);
    }
}

.

static final class AbstractThrowableAssertHasMessage {
    
    @BeforeTemplate
    AbstractThrowableAssert<?, ? extends Throwable> before(AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert, String message, @Repeated
    Object parameters) {
        return abstractThrowableAssert.hasMessage(message.formatted(parameters));
    }
    
    @AfterTemplate
    AbstractThrowableAssert<?, ? extends Throwable> after(AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert, String message, @Repeated
    Object parameters) {
        return abstractThrowableAssert.hasMessage(message, parameters);
    }
}

.

static final class AbstractThrowableAssertWithFailMessage {
    
    @BeforeTemplate
    AbstractThrowableAssert<?, ? extends Throwable> before(AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert, String message, @Repeated
    Object args) {
        return abstractThrowableAssert.withFailMessage(message.formatted(args));
    }
    
    @AfterTemplate
    AbstractThrowableAssert<?, ? extends Throwable> after(AbstractThrowableAssert<?, ? extends Throwable> abstractThrowableAssert, String message, @Repeated
    Object args) {
        return abstractThrowableAssert.withFailMessage(message, args);
    }
}

.

static final class AssertThatThrownByHasMessageParameters {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByAsInstanceOfThrowable")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType, String message, @Repeated
    Object parameters) {
        return assertThatExceptionOfType(exceptionType).isThrownBy(throwingCallable).withMessage(message, parameters);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, Class<? extends Throwable> exceptionType, String message, @Repeated
    Object parameters) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(exceptionType).hasMessage(message, parameters);
    }
}

.

static final class AssertThatThrownByIOExceptionHasMessageParameters {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIOException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatIOException().isThrownBy(throwingCallable).withMessage(message, parameters);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IOException.class).hasMessage(message, parameters);
    }
}

.

static final class AssertThatThrownByIllegalArgumentExceptionHasMessageNotContainingAny {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIllegalArgumentException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, @Repeated
    CharSequence values) {
        return assertThatIllegalArgumentException().isThrownBy(throwingCallable).withMessageNotContainingAny(values);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, @Repeated
    CharSequence values) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalArgumentException.class).hasMessageNotContainingAny(values);
    }
}

.

static final class AssertThatThrownByIllegalArgumentExceptionHasMessageParameters {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIllegalArgumentException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatIllegalArgumentException().isThrownBy(throwingCallable).withMessage(message, parameters);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalArgumentException.class).hasMessage(message, parameters);
    }
}

.

static final class AssertThatThrownByIllegalStateExceptionHasMessageParameters {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByIllegalStateException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatIllegalStateException().isThrownBy(throwingCallable).withMessage(message, parameters);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(IllegalStateException.class).hasMessage(message, parameters);
    }
}

.

static final class AssertThatThrownByNullPointerExceptionHasMessageParameters {
    
    @BeforeTemplate
    @SuppressWarnings(value = "AssertThatThrownByNullPointerException")
    AbstractObjectAssert<?, ?> before(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatNullPointerException().isThrownBy(throwingCallable).withMessage(message, parameters);
    }
    
    @AfterTemplate
    @UseImportPolicy(value = STATIC_IMPORT_ALWAYS)
    AbstractObjectAssert<?, ?> after(ThrowingCallable throwingCallable, String message, @Repeated
    Object parameters) {
        return assertThatThrownBy(throwingCallable).isInstanceOf(NullPointerException.class).hasMessage(message, parameters);
    }
}

.

Removed Recipes​

  • org.openrewrite.github.PreferSecretsInheritWorkflow: Pass all secrets to a reusable workflow using secrets: inherit. See Simplify using secrets with reusable workflows for details.
  • tech.picnic.errorprone.refasterrules.AssortedRulesRecipes$DisjointCollectionsRecipe: Don't unnecessarily copy collections before passing them to Collections#disjoint(Collection, Collection).
  • tech.picnic.errorprone.refasterrules.AssortedRulesRecipes$DisjointSetsRecipe: Prefer Collections#disjoint(Collection, Collection) over more contrived alternatives.
  • tech.picnic.errorprone.refasterrules.FileRulesRecipes$FilesNewBufferedReaderPathOfRecipe: Prefer Files#newBufferedReader(Path) over more verbose or contrived alternatives.
  • tech.picnic.errorprone.refasterrules.FileRulesRecipes$FilesNewBufferedReaderPathOfWithCharsetRecipe: Prefer Files#newBufferedReader(Path, Charset) over more contrived alternatives.
  • tech.picnic.errorprone.refasterrules.FileRulesRecipes$FilesNewBufferedReaderToPathRecipe: Prefer Files#newBufferedReader(Path) over more verbose or contrived alternatives.
  • tech.picnic.errorprone.refasterrules.FileRulesRecipes$FilesNewBufferedReaderToPathWithCharsetRecipe: Prefer Files#newBufferedReader(Path, Charset) over more contrived alternatives.