@openrewrite/rewrite 8.92.17 → 8.92.18

package/src/rpc/queue.ts

@@ -52,12 +52,27 @@ export interface RpcCodec<T> {
     rpcReceive(before: T, q: RpcReceiveQueue): Promise<T>;
 }
 
+/**
+ * Converts a type that has no {@link RpcCodec} on either side, and so travels as one inline value,
+ * between its shape here and the one the peer's serializer gives it.
+ */
+export interface RpcValueCodec<T> {
+    /**
+     * @param value The value as the peer serialized it, with its `kind` and without its top-level serializer keys.
+     */
+    fromValue(value: any): T;
+
+    toValue(after: T): any;
+}
+
 /**
  * A registry for managing RPC codecs based on object types.
  */
 export class RpcCodecs {
     private static nonTreeCodecs = new Map<string, RpcCodec<any>>();
 
+    private static valueCodecs = new Map<string, RpcValueCodec<any>>();
+
     /**
      * The first key is on sourceFileType and the second on object type
      */
@@ -98,6 +113,14 @@ export class RpcCodecs {
         return this.nonTreeCodecs.get(type);
     }
 
+    static registerValueCodec(type: string, codec: RpcValueCodec<any>): void {
+        this.valueCodecs.set(type, codec);
+    }
+
+    static valueCodecForType(type: string): RpcValueCodec<any> | undefined {
+        return this.valueCodecs.get(type);
+    }
+
     /**
      * Determines the appropriate codec for an instance based on its `kind` property.
      *
@@ -204,7 +227,7 @@ export class RpcSendQueue {
                 await this.add(after, onChange);
             } else {
                 let afterCodec = onChange ? undefined : RpcCodecs.forInstance(after, this.sourceFileType);
-                this.put({state: RpcObjectState.CHANGE, value: onChange || afterCodec ? undefined : after});
+                this.put(this.valueMessage(RpcObjectState.CHANGE, after, !onChange && !afterCodec));
                 await this.doChange(after, before, onChange, afterCodec);
             }
         });
@@ -239,7 +262,7 @@ export class RpcSendQueue {
                         const afterCodec = onChangeRun ? undefined : RpcCodecs.forInstance(anAfter, this.sourceFileType);
                         // Without an onChange callback or codec, no property messages follow, so the
                         // value must travel inline (as in send()) or the receiver keeps the stale element
-                        this.put({state: RpcObjectState.CHANGE, value: onChangeRun || afterCodec ? undefined : anAfter});
+                        this.put(this.valueMessage(RpcObjectState.CHANGE, anAfter, !onChangeRun && !afterCodec));
                         await this.doChange(anAfter, aBefore, onChangeRun, afterCodec);
                     }
                 }
@@ -288,14 +311,23 @@ export class RpcSendQueue {
         }
         let afterCodec = onChange ? undefined : RpcCodecs.forInstance(after, this.sourceFileType);
         this.put({
-            state: RpcObjectState.ADD,
+            ...this.valueMessage(RpcObjectState.ADD, after, !onChange && !afterCodec),
             valueType: this.getValueType(after),
-            value: onChange || afterCodec ? undefined : after,
             ref: ref
         });
         await this.doChange(after, undefined, onChange, afterCodec);
     }
 
+    // An inline value carries its type even in a CHANGE, as the peer needs it to decode the value
+    private valueMessage(state: RpcObjectState, after: any, inline: boolean): RpcObjectData {
+        if (!inline) {
+            return {state};
+        }
+        const valueType = this.getValueType(after);
+        const valueCodec = valueType === undefined ? undefined : RpcCodecs.valueCodecForType(valueType);
+        return {state, valueType, value: valueCodec ? valueCodec.toValue(after) : after};
+    }
+
     private async doChange(after: any, before: any, onChange?: () => Promise<void>, afterCodec?: RpcCodec<any>): Promise<void> {
         const lastBefore = this.before;
         this.before = before;
@@ -526,7 +558,7 @@ export class RpcReceiveQueue {
                     after = await codec.rpcReceive(before, this);
                 } else if (message.value !== undefined) {
                     after = message.valueType ?
-                        {kind: this.internedStrings.internType(message.valueType), ...withoutSerializerKeys(message.value)} :
+                        this.inlineValue(message.valueType, message.value) :
                         typeof message.value === "string" ? this.internedStrings.internValue(message.value) : message.value;
                 } else if (message.state === RpcObjectState.ADD && message.valueType) {
                     throw new Error(
@@ -608,6 +640,13 @@ export class RpcReceiveQueue {
         }
     }
 
+    private inlineValue(valueType: string, value: any): any {
+        const kind = this.internedStrings.internType(valueType);
+        const valueCodec = RpcCodecs.valueCodecForType(kind);
+        const typed = {kind, ...withoutSerializerKeys(value)};
+        return valueCodec ? valueCodec.fromValue(typed) : typed;
+    }
+
     private newObj<T>(type: string): T {
         const codec = RpcCodecs.forType(type, this.sourceFileType);
         if (codec?.rpcNew) {

package/src/rpc/request/prepare-recipe.ts

@@ -26,7 +26,10 @@ import {withMetrics} from "./metrics";
 import {RecipeMarketplace} from "../../marketplace";
 
 export class PrepareRecipe {
-    constructor(private readonly id: string, private readonly options?: any) {
+    constructor(private readonly id: string,
+                private readonly options?: any,
+                // Older Java hosts reject unknown response fields, so causesAnotherCycle is only sent when asked.
+                private readonly acceptsCausesAnotherCycle?: boolean) {
     }
 
     static handle(connection: MessageConnection,
@@ -41,18 +44,19 @@ export class PrepareRecipe {
                 metricsCsv,
                 (context) => async (request) => {
                     context.target = request.id;
+                    const accepts = request.acceptsCausesAnotherCycle === true;
                     const recipeCtor = marketplace.findRecipe(request.id);
                     if (!recipeCtor) {
                         // A miss means the host owns this recipe (e.g. a Java-delegate child a host
                         // re-prepares by name), so answer with a delegatesTo stand-in for it to resolve.
                         return await PrepareRecipe.prepareInstance(new DelegatingRecipe(request.id, request.options ?? {}),
-                            snowflake, preparedRecipes, marketplace);
+                            snowflake, preparedRecipes, marketplace, accepts);
                     }
                     if (!recipeCtor[1]) {
                         throw new Error(`Recipe ${request.id} was installed without a constructor`);
                     }
                     return await PrepareRecipe.prepareInstance(new recipeCtor[1](request.options),
-                        snowflake, preparedRecipes, marketplace);
+                        snowflake, preparedRecipes, marketplace, accepts);
                 }
             )
         );
@@ -68,7 +72,8 @@ export class PrepareRecipe {
     private static async prepareInstance(recipe: Recipe,
                                          snowflake: ReturnType<typeof SnowflakeId>,
                                          preparedRecipes: Map<String, Recipe>,
-                                         marketplace: RecipeMarketplace): Promise<PrepareRecipeResponse> {
+                                         marketplace: RecipeMarketplace,
+                                         acceptsCausesAnotherCycle: boolean): Promise<PrepareRecipeResponse> {
         const id = snowflake.generate();
         const delegatesTo = PrepareRecipe.delegatesTo(recipe);
         if (delegatesTo) {
@@ -106,6 +111,9 @@ export class PrepareRecipe {
             scanVisitor: recipe instanceof ScanningRecipe ? `scan:${id}` : undefined,
             scanPreconditions: scanPreconditions
         };
+        if (acceptsCausesAnotherCycle && recipe.causesAnotherCycle === true) {
+            response.causesAnotherCycle = true;
+        }
 
         const childResponses: PrepareRecipeResponse[] = [];
         for (const child of await recipe.recipeList()) {
@@ -118,7 +126,7 @@ export class PrepareRecipe {
                     }
                 }
                 childResponses.push(await PrepareRecipe.prepareInstance(new DelegatingRecipe(child.name, options),
-                    snowflake, preparedRecipes, marketplace));
+                    snowflake, preparedRecipes, marketplace, acceptsCausesAnotherCycle));
                 continue;
             }
             // Register a child that was instantiated in recipeList() but never installed, so a peer
@@ -126,7 +134,8 @@ export class PrepareRecipe {
             if (!PrepareRecipe.delegatesTo(child) && !marketplace.findRecipe(child.name)) {
                 await marketplace.install(child.constructor as any, []);
             }
-            childResponses.push(await PrepareRecipe.prepareInstance(child, snowflake, preparedRecipes, marketplace));
+            childResponses.push(await PrepareRecipe.prepareInstance(child, snowflake, preparedRecipes, marketplace,
+                acceptsCausesAnotherCycle));
         }
         response.recipeList = childResponses;
 
@@ -276,6 +285,7 @@ export interface PrepareRecipeResponse {
      * locally from these instead of re-preparing each child by name (the whole-tree optimization).
      */
     recipeList?: PrepareRecipeResponse[]
+    causesAnotherCycle?: boolean
 }
 
 /**

package/src/search/is-source-file.ts

@@ -5,12 +5,17 @@ import {foundSearchResult} from "../markers";
 import * as picomatch from "picomatch";
 
 export class IsSourceFile extends TreeVisitor<any, ExecutionContext> {
-    private readonly matcher: picomatch.Matcher;
+    private readonly matcher: (path: string) => boolean;
 
+    /** Reads and matches `filePattern` the way Java's FindSourceFiles does, so the precondition agrees on both hosts. */
     constructor(filePattern: string) {
         super();
-        // Create a picomatch matcher for the pattern
-        this.matcher = picomatch.default ? picomatch.default(filePattern) : (picomatch as any)(filePattern);
+        const patterns = filePattern.split(";")
+            .map(p => p.trim().replace(/^\.?[/\\]/, ""))
+            .filter(p => p.length > 0);
+        const options = {dot: true};
+        this.matcher = patterns.length === 0 ? () => true :
+            picomatch.default ? picomatch.default(patterns, options) : (picomatch as any)(patterns, options);
     }
 
     protected async preVisit(tree: any, _: ExecutionContext): Promise<any> {

package/src/test/rewrite-test.ts

@@ -24,6 +24,7 @@ import {mapAsync, trimIndent} from "../util";
 import {ParseErrorKind} from "../parse-error";
 import {MarkersKind, ParseExceptionResult} from "../markers";
 import {JavaScriptVisitor} from "../javascript";
+import {attributionHint, dumpTypesIfRequested} from "../javascript/type-report";
 import {J} from "../java";
 
 export interface SourceSpec<T extends SourceFile> {
@@ -117,6 +118,11 @@ export class RecipeSpec {
         RecipeSpec.live &&= [];
     }
 
+    /**
+     * Setting `REWRITE_JAVASCRIPT_DUMP_TYPES` prints each parsed file's type attribution, and a
+     * recipe that produces no change names the nodes that carry none. See the README section
+     * "Inspecting type attribution".
+     */
     async rewriteRun(...sourceSpecs: (SourceSpec<any> | Generator<SourceSpec<any>, void, unknown> | AsyncGenerator<SourceSpec<any>, void, unknown>)[]): Promise<void> {
         // Flatten generators into a list of sourceSpecs
         const flattenedSpecs: SourceSpec<any>[] = [];
@@ -152,6 +158,9 @@ export class RecipeSpec {
             const specs = specsByKind[kind];
             const parsed = await this.parse(specs);
             await this.expectNoParseFailures(parsed);
+            for (const [_, sourceFile] of parsed) {
+                await dumpTypesIfRequested(sourceFile);
+            }
             await this.expectWhitespaceNotToContainNonwhitespaceCharacters(parsed);
             this.checkParsePrintIdempotence && await this.expectParsePrintIdempotence(parsed);
             allParsed.push(...parsed);
@@ -245,7 +254,7 @@ export class RecipeSpec {
                     await spec.afterRecipe(matchingSpec![1]);
                 }
             } else {
-                await this.expectAfter(spec, after);
+                await this.expectAfter(spec, after, matchingSpec?.[1]);
             }
         }
     }
@@ -263,7 +272,7 @@ export class RecipeSpec {
         }
     }
 
-    private async expectAfter(spec: SourceSpec<any>, after?: SourceFile) {
+    private async expectAfter(spec: SourceSpec<any>, after?: SourceFile, before?: SourceFile) {
         if (!after) {
             throw new Error('Expected for recipe to have produced a change for file:\n' + trimIndent(spec.before))
         }
@@ -272,9 +281,11 @@ export class RecipeSpec {
         const afterSource = typeof spec.after === "function" ?
             (spec.after as (actual: string) => string)(actualAfter) : spec.after as string;
         if (actualAfter !== afterSource) {
+            // A tree the recipe returned unchanged usually means it never fired.
+            const hint = after === before ? await attributionHint(after) : "";
             throw new Error(
                 `Recipe output does not match expected.\n` +
-                `Expected:\n${afterSource}\n\nActual:\n${actualAfter}`
+                `Expected:\n${afterSource}\n\nActual:\n${actualAfter}${hint}`
             );
         }
         if (spec.afterRecipe) {