Merge remote-tracking branch 'origin/main' into lunar-lynx

# Conflicts:
#	rewrite-javascript/rewrite/src/javascript/parser.ts

Author: knutwannheden

.github/workflows/comment-pr.yml

@@ -27,6 +27,7 @@ rewrite-java-25
 
 # Other language modules
 
+rewrite-docker
 rewrite-gradle
 rewrite-groovy
 rewrite-hcl

.github/workflows/receive-pr.yml

@@ -22,3 +22,11 @@ allprojects {
     group = "org.openrewrite"
     description = "Eliminate tech-debt. Automatically."
 }
+
+// Use this task locally between different dependency check runs to have updated analysis:
+// OSSINDEX_PASSWORD=... OSSINDEX_USERNAME=... gradle cleanReports dCAg --no-parallel
+tasks.register<Delete>("cleanReports") {
+    description = "Removes build/reports folder from all modules"
+    group = "owasp dependency-check"
+    delete(allprojects.map { it.layout.buildDirectory.dir("reports") })
+}

IDE.properties.tmp

@@ -46,5 +46,5 @@ tasks.withType<Javadoc> {
     //   symbol:   method onConstructor_()
     //   location: @interface AllArgsConstructor
     // 1 error
-    exclude("**/RpcObjectData.java")
+    exclude("**/RpcObjectData.java", "**/RecipeDescriptor.java")
 }

build.gradle.kts

@@ -25,6 +25,7 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.UncheckedIOException;
 import java.net.URI;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -83,6 +84,10 @@ public static Checksum fromUri(HttpSender httpSender, URI uri, String algorithm)
                 .withMethod(HttpSender.Method.GET)
                 .build();
         try (HttpSender.Response response = httpSender.send(request)) {
+            if (!response.isSuccessful()) {
+                throw new UncheckedIOException(new IOException(
+                        "Failed to download checksum from " + uri + ": HTTP " + response.getCode()));
+            }
             String hexString = new String(response.getBodyAsBytes(), StandardCharsets.UTF_8);
             return Checksum.fromHex(algorithm, hexString);
         }

rewrite-core/build.gradle.kts

@@ -99,4 +99,17 @@ default void afterCycle(boolean lastCycle) {
      */
     @Nullable
     SourceFile getBefore(Path sourcePath);
+
+    /**
+     * Called when a recipe's {@code generate()} produces a file whose path collides with
+     * an existing source file or with another generated file. The generated file is silently
+     * dropped. Implementations may override this to detect the collision (e.g. the test
+     * framework raises an assertion failure).
+     *
+     * @param sourcePath    The colliding source path.
+     * @param existingFile  {@code true} if the collision is with an existing source file,
+     *                      {@code false} if it's with another generated file.
+     */
+    default void onGenerateCollision(Path sourcePath, boolean existingFile) {
+    }
 }

rewrite-core/src/main/java/org/openrewrite/Checksum.java

@@ -203,8 +203,6 @@ public String getInstanceNameSuffix() {
      * A set of strings used for categorizing related recipes. For example
      * "testing", "junit", "spring". Any individual tag should consist of a
      * single word, all lowercase.
-     *
-     * @return The tags.
      */
     @Getter
     final Set<String> tags = emptySet();
@@ -225,11 +223,21 @@ public final RecipeDescriptor getDescriptor() {
 
     protected RecipeDescriptor createRecipeDescriptor() {
         List<OptionDescriptor> options = getOptionDescriptors();
-        ArrayList<RecipeDescriptor> recipeList1 = new ArrayList<>();
-        for (Recipe next : getRecipeList()) {
-            recipeList1.add(next.getDescriptor());
+        List<RecipeDescriptor> preconditionDescriptors = emptyList();
+        if (this instanceof RecipePreconditions) {
+            RecipePreconditions recipeWithPreconditions = (RecipePreconditions) this;
+            List<Recipe> preconditions = recipeWithPreconditions.getPreconditions();
+            preconditionDescriptors = new ArrayList<>(preconditions.size());
+            for (Recipe precondition : preconditions) {
+                preconditionDescriptors.add(precondition.getDescriptor());
+            }
+        }
+
+        List<Recipe> recipeList = getRecipeList();
+        List<RecipeDescriptor> recipeDescriptors = new ArrayList<>(recipeList.size());
+        for (Recipe next : recipeList) {
+            recipeDescriptors.add(next.getDescriptor());
         }
-        recipeList1.trimToSize();
 
         URI recipeSource;
         try {
@@ -239,7 +247,7 @@ protected RecipeDescriptor createRecipeDescriptor() {
         }
 
         return new RecipeDescriptor(getName(), getDisplayName(), getInstanceName(), getDescription(), getTags(),
-                getEstimatedEffortPerOccurrence(), options, recipeList1, getDataTableDescriptors(),
+                getEstimatedEffortPerOccurrence(), options, preconditionDescriptors, recipeDescriptors, getDataTableDescriptors(),
                 getMaintainers(), getContributors(), getExamples(), recipeSource);
     }
 
@@ -449,12 +457,7 @@ public final RecipeRun run(LargeSourceSet before, ExecutionContext ctx, int maxC
 
     @SuppressWarnings("unused")
     public Validated<Object> validate(ExecutionContext ctx) {
-        Validated<Object> validated = validate();
-
-        for (Recipe recipe : getRecipeList()) {
-            validated = validated.and(recipe.validate(ctx));
-        }
-        return validated;
+        return validate();
     }
 
     /**
@@ -475,9 +478,6 @@ public Validated<Object> validate() {
                 validated = Validated.invalid(field.getName(), null, "Unable to access " + clazz.getName() + "." + field.getName(), e);
             }
         }
-        for (Recipe recipe : getRecipeList()) {
-            validated = validated.and(recipe.validate());
-        }
         return validated;
     }
 
@@ -561,6 +561,10 @@ public Recipe withOptions(@Nullable Map<String, Object> options) {
                         Map<String, Object> option = new HashMap<>();
                         option.put("value", value);
                         objectMapper.updateValue(optionDescriptor, option);
+
+                        if (optionDescriptor.getType().equals("List")) {
+                            m.put(optionDescriptor.getName(), Arrays.asList(((String) value).split(",")));
+                        }
                     }
                 }
             }

rewrite-core/src/main/java/org/openrewrite/LargeSourceSet.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite;
+
+import lombok.EqualsAndHashCode;
+import lombok.Value;
+import org.jspecify.annotations.Nullable;
+
+import java.net.URI;
+
+@Value
+@EqualsAndHashCode(callSuper = false)
+public class RecipeNotFoundException extends RuntimeException {
+    String recipeName;
+
+    @Nullable
+    URI source;
+
+    public RecipeNotFoundException(String recipeName) {
+        this(recipeName, null);
+    }
+
+    public RecipeNotFoundException(String recipeName, @Nullable URI source) {
+        super("Unable to find recipe " + recipeName + (source == null ? "" : " listed in " + source));
+        this.recipeName = recipeName;
+        this.source = source;
+    }
+}

rewrite-core/src/main/java/org/openrewrite/Recipe.java

@@ -73,8 +73,7 @@ private LargeSourceSet runRecipeCycles(Recipe recipe, LargeSourceSet sourceSet,
                 // use cases like sharing a `JavaTypeCache` between `JavaTemplate` parsers).
                 Cursor rootCursor = new Cursor(null, Cursor.ROOT_VALUE);
                 try {
-                    RecipeRunCycle<LargeSourceSet> cycle = new RecipeRunCycle<>(recipe, i, rootCursor, ctxWithWatch,
-                            recipeRunStats, searchResults, sourceFileResults, errorsTable, LargeSourceSet::edit);
+                    RecipeRunCycle<LargeSourceSet> cycle = createRecipeRunCycle(recipe, i, rootCursor, ctxWithWatch, recipeRunStats, searchResults, sourceFileResults, errorsTable);
                     ctxWithWatch.putCycle(cycle);
                     after.beforeCycle(i == maxCycles);
 
@@ -117,6 +116,11 @@ private LargeSourceSet runRecipeCycles(Recipe recipe, LargeSourceSet sourceSet,
         return after;
     }
 
+    protected RecipeRunCycle<LargeSourceSet> createRecipeRunCycle(Recipe recipe, int cycle, Cursor rootCursor, WatchableExecutionContext ctxWithWatch, RecipeRunStats recipeRunStats, SearchResults searchResults, SourcesFileResults sourceFileResults, SourcesFileErrors errorsTable) {
+        return new RecipeRunCycle<>(recipe, cycle, rootCursor, ctxWithWatch,
+                recipeRunStats, searchResults, sourceFileResults, errorsTable, LargeSourceSet::edit);
+    }
+
     private void recursiveOnComplete(Recipe recipe, ExecutionContext ctx) {
         recipe.onComplete(ctx);
         for (Recipe r : recipe.getRecipeList()) {