@openrewrite/rewrite 8.95.0 → 8.96.1

package/src/javascript/amd.ts

@@ -513,8 +513,11 @@ export function withoutDependencyAt(
     block: AmdBlock,
     index: number
 ): J.MethodInvocation {
-    const dependencies = withElements(block.dependencies, removeEntry(elementsOf(block), index, dependencySlot));
     const parameters = parametersOf(block);
+    if (index < 0 || index >= Math.max(elementsOf(block).length, parameters.length)) {
+        return call;
+    }
+    const dependencies = withElements(block.dependencies, removeEntry(elementsOf(block), index, dependencySlot));
     const factory = index >= parameters.length ?
         block.factory :
         withParameters(block.factory, removeEntry(parameters, index, parameterSlot));
@@ -644,6 +647,11 @@ function queuedFor(visitor: JavaScriptVisitor<any>, blockId: UUID): AddAmdDepend
     return visitor.afterVisit.filter((v): v is AddAmdDependency<any> => v instanceof AddAmdDependency && v.blockId === blockId);
 }
 
+/** Whether `scope` is where the factory's parameters are declared, which for an arrow is the arrow wrapping its lambda. */
+function declaresParameters(scope: J | undefined, factory: J.MethodDeclaration | J.Lambda): boolean {
+    return scope === factory || (scope?.kind === JS.Kind.ArrowFunction && (scope as JS.ArrowFunction).lambda === factory);
+}
+
 /**
  * A local binding for `module` on the AMD lane, creating one where the block does not already
  * have it, or `undefined` where no safe binding exists.
@@ -662,18 +670,19 @@ export function bindAmd(
     const modules = dependencyNames(amd.block);
     const bindings = parameterNames(amd.block);
 
-    const declared = module === "" ? -1 : modules.indexOf(module);
-    if (declared >= 0) {
-        const bound = bindings[declared];
-        if (bound === undefined) {
-            // A parameter that is not a plain name gives the module no binding to hand back.
-            return undefined;
-        }
-        // Only code the factory encloses can shadow its parameter, so a cursor elsewhere in the
-        // block — on the `define` call, or on its dependency array — has nothing to measure.
-        const cursor = cursorOf(visitor);
-        const withinFactory = cursor?.firstEnclosing((v): v is J => v === amd.block.factory);
-        if (withinFactory === undefined || scopeOf(cursor!).declaringScope(bound) === amd.block.factory) {
+    const declared = module === "" ? [] : modules.flatMap((m, i) => m === module ? [i] : []);
+    if (declared.length > 0 && bindings[declared[0]] === undefined) {
+        // A parameter that is not a plain name gives the module no binding to hand back.
+        return undefined;
+    }
+    // Only code the factory encloses can shadow its parameter, so a cursor elsewhere in the
+    // block — on the `define` call, or on its dependency array — has nothing to measure.
+    const cursor = cursorOf(visitor);
+    const withinFactory = cursor?.firstEnclosing((v): v is J => v === amd.block.factory);
+    for (const index of declared) {
+        const bound = bindings[index];
+        if (bound !== undefined && (withinFactory === undefined ||
+            declaresParameters(scopeOf(cursor!).declaringScope(bound), amd.block.factory))) {
             return bound;
         }
     }

package/src/javascript/format/format.ts

@@ -255,6 +255,9 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
 
     public async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
         const ret = await super.visitContainer(container, p) as J.Container<T>;
+        if (this.cursor.value?.kind === J.Kind.TypeParameter) {
+            return ret;
+        }
         return produce(ret, draft => {
             if (draft.elements.length > 0) {
                 // Apply beforeComma rule to all elements except the last
@@ -321,7 +324,7 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         const ret = await super.visitForLoop(forLoop, p) as J.ForLoop;
         return produceAsync(ret, async draft => {
             draft.control.prefix.whitespace = this.style.beforeParentheses.forParentheses ? " " : "";
-            draft.control.init = await Promise.all(draft.control.init.map(async (oneInit, index) => {
+            draft.control.init.forEach((oneInit, index) => {
                 if (oneInit.element.kind === J.Kind.VariableDeclarations) {
                     const vd = oneInit.element as Draft<J.VariableDeclarations>;
                     if (vd.modifiers && vd.modifiers.length > 0) {
@@ -330,8 +333,7 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                 }
                 oneInit.after.whitespace = "";
                 this.spaceBeforeRightPaddedElementDraft(oneInit, index === 0 ? this.style.within.forParentheses : true);
-                return oneInit;
-            }));
+            });
             if (draft.control.condition) {
                 draft.control.condition.element.prefix.whitespace = " ";
                 draft.control.condition.after.whitespace = this.style.other.beforeForSemicolon ? " " : "";
@@ -641,9 +643,14 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                 const hasConstraint = constraintType.element.kind !== J.Kind.Empty;
                 const hasDefault = defaultType.element.kind !== J.Kind.Empty;
 
+                if (hasDefault && !defaultType.element.prefix.whitespace.includes("\n")) {
+                    defaultType.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
+                }
                 if (hasConstraint) {
-                    // Space before '=' for default type (in the `after` of constraint type)
-                    if (hasDefault && !constraintType.after.whitespace.includes("\n")) {
+                    if (!hasDefault) {
+                        this.spaceAfterRightPaddedDraft(constraintType, this.style.other.beforeComma);
+                    } else if (!constraintType.after.whitespace.includes("\n")) {
+                        // Space before '=' for default type (in the `after` of constraint type)
                         constraintType.after.whitespace = this.style.aroundOperators.assignment ? " " : "";
                     }
                 } else if (hasDefault) {

package/src/javascript/recipes/order-imports.ts

@@ -172,43 +172,39 @@ export class OrderImports extends Recipe {
                                 return; // Nothing to sort
                             }
 
-                            // Handle trailing comma
-                            const trailingComma = elements.length > 0 &&
-                                elements[elements.length - 1].markers?.markers.find(m => m.kind === J.Markers.TrailingComma);
-                            if (trailingComma) {
-                                elements[elements.length - 1].markers.markers =
-                                    elements[elements.length - 1].markers.markers.filter(m => m.kind !== J.Markers.TrailingComma);
-                            }
+                            const bySortKey = (a: { element: unknown }, b: { element: unknown }) =>
+                                this.getSpecifierSortKey(a.element as JS.ImportSpecifier)
+                                    .localeCompare(this.getSpecifierSortKey(b.element as JS.ImportSpecifier));
+                            if (elements.some((e, i) => i > 0 && bySortKey(elements[i - 1], e) > 0)) {
+                                const trailingComma = elements[elements.length - 1].markers?.markers.find(m => m.kind === J.Markers.TrailingComma);
+                                if (trailingComma) {
+                                    elements[elements.length - 1].markers.markers =
+                                        elements[elements.length - 1].markers.markers.filter(m => m.kind !== J.Markers.TrailingComma);
+                                }
+
+                                elements.sort(bySortKey);
 
-                            // Sort by the imported name (not alias)
-                            elements.sort((a, b) => {
-                                const nameA = this.getSpecifierSortKey(a.element as JS.ImportSpecifier);
-                                const nameB = this.getSpecifierSortKey(b.element as JS.ImportSpecifier);
-                                return nameA.localeCompare(nameB);
-                            });
+                                if (trailingComma) {
+                                    elements[elements.length - 1].markers.markers.push(trailingComma);
+                                }
+                            }
 
-                            // Normalize spacing based on es6ImportExportBraces style
                             const braceSpace = useBraceSpaces ? " " : "";
+                            const differs = (space: J.Space, whitespace: string) =>
+                                space.whitespace !== whitespace || space.comments.length > 0;
+                            const spaceOf = (whitespace: string): J.Space => ({kind: J.Kind.Space, whitespace, comments: []});
                             for (let i = 0; i < elements.length; i++) {
-                                if (i === 0) {
-                                    // First element: space after opening brace based on style
-                                    elements[i].element.prefix = {kind: J.Kind.Space, whitespace: braceSpace, comments: []};
-                                } else {
-                                    // Other elements: space after comma
-                                    elements[i].element.prefix = {kind: J.Kind.Space, whitespace: ' ', comments: []};
+                                const whitespace = i === 0 ? braceSpace : ' ';
+                                if (differs(elements[i].element.prefix, whitespace)) {
+                                    elements[i].element.prefix = spaceOf(whitespace);
                                 }
                             }
-                            // Last element: space before closing brace based on style
-                            elements[elements.length - 1].after = {kind: J.Kind.Space, whitespace: braceSpace, comments: []};
-
-                            // Restore trailing comma to last element
-                            if (trailingComma && elements.length > 0 &&
-                                !elements[elements.length - 1].markers.markers.find(m => m.kind === J.Markers.TrailingComma)) {
-                                elements[elements.length - 1].markers.markers.push(trailingComma);
+                            if (differs(elements[elements.length - 1].after, braceSpace)) {
+                                elements[elements.length - 1].after = spaceOf(braceSpace);
                             }
                         });
 
-                        ret.push(produce(importPadded, draft => {
+                        ret.push(importSorted === import_ ? importPadded : produce(importPadded, draft => {
                             draft.element = importSorted;
                         }));
                     } else {

package/src/javascript/search/find-dependency.ts

@@ -163,6 +163,9 @@ export class FindDependency extends Recipe {
             private async markDependency(member: Json.Member, ctx: ExecutionContext): Promise<Json.Member> {
                 const visitedMember = await super.visitMember(member, ctx) as Json.Member;
                 const markedKey = foundSearchResult(visitedMember.key.element);
+                if (markedKey === visitedMember.key.element) {
+                    return visitedMember;
+                }
                 return {
                     ...visitedMember,
                     key: {

package/src/markers.ts

@@ -275,6 +275,10 @@ export function markupDebug<T extends { markers: Markers }>(t: T, message: strin
  * Helper to add a markup marker to a tree node.
  */
 function addMarkup<T extends { markers: Markers }>(t: T, markup: Markup): T {
+    if (t.markers.markers.some(m => m.kind === markup.kind &&
+        (m as Markup).message === markup.message && (m as Markup).detail === markup.detail)) {
+        return t;
+    }
     return {
         ...t,
         markers: {

package/src/test/rewrite-test.ts

@@ -27,6 +27,7 @@ import {isNamedStyles} from "../style";
 import {JavaScriptVisitor} from "../javascript";
 import {attributionHint, dumpTypesIfRequested} from "../javascript/type-report";
 import {J, Type} from "../java";
+import {DATA_TABLE_STORE} from "../data-table";
 
 export interface SourceSpec<T extends SourceFile> {
     kind: string,
@@ -44,6 +45,8 @@ interface RecipeSpecConfiguration {
     checkParsePrintIdempotence: boolean;
     allowEmptyDiff: boolean;
     checkReportingMarkersOnly: boolean;
+    cycles?: number;
+    expectedCyclesThatMakeChanges?: number;
     recipe: Recipe;
     recipeExecutionContext: ExecutionContext;
     dataTableAssertions: { [key: string]: (rows: any[]) => void };
@@ -59,6 +62,19 @@ export class RecipeSpec {
      */
     checkReportingMarkersOnly: boolean = true
 
+    /**
+     * The cycles to run, by default one more than {@link expectedCyclesThatMakeChanges} and at least two. The
+     * cycles after the expected ones, and a run on a fresh parse of the output, fail the test if they change
+     * anything, so setting this to 1 turns the stability checks off.
+     */
+    cycles?: number
+
+    /**
+     * How many cycles a recipe needs to settle, by default 1. A recipe that only reaches its result over
+     * several cycles declares how many here, and the test then compares the output of the last of them.
+     */
+    expectedCyclesThatMakeChanges?: number
+
     recipe: Recipe = new NoopRecipe()
 
     /**
@@ -94,6 +110,8 @@ export class RecipeSpec {
             checkParsePrintIdempotence: this.checkParsePrintIdempotence,
             allowEmptyDiff: this.allowEmptyDiff,
             checkReportingMarkersOnly: this.checkReportingMarkersOnly,
+            cycles: this.cycles,
+            expectedCyclesThatMakeChanges: this.expectedCyclesThatMakeChanges,
             recipe: this.recipe,
             recipeExecutionContext: this.recipeExecutionContext,
             dataTableAssertions: {...this.dataTableAssertions}
@@ -194,19 +212,142 @@ export class RecipeSpec {
             }
         }
 
-        const changeset = (await scheduleRun(this.recipe,
-            allParsed.map(([_, sourceFile]) => sourceFile),
-            this.recipeExecutionContext)).changeset;
+        const expectedCycles = this.expectedCyclesThatMakeChanges ?? 1;
+        const cycles = this.cycles ?? Math.max(2, expectedCycles + 1);
+        const {changeset, unsettled} = await this.runCycles(allParsed.map(([_, sourceFile]) => sourceFile),
+            cycles, expectedCycles);
 
         this.checkReportingMarkersOnly && await this.expectNoAddedMarkers(flattenedSpecs, allParsed, changeset);
         await this.expectResultsToMatchAfter(flattenedSpecs, changeset, allParsed);
         await this.expectGeneratedFiles(flattenedSpecs, changeset);
+        if (unsettled) {
+            await this.expectNoFurtherChanges(unsettled.changes,
+                `Expected recipe to complete in ${pluralCycles(expectedCycles)}, but cycle ${unsettled.cycle} changed`);
+        }
+        cycles > expectedCycles && await this.expectStableOnFreshParse(flattenedSpecs, allParsed, changeset);
 
         // for (const [name, assertion] of Object.entries(this.dataTableAssertions)) {
         //     assertion(getRows(name, this.recipeExecutionContext));
         // }
     }
 
+    private async runCycles(sources: SourceFile[], cycles: number, expectedCycles: number):
+        Promise<{ changeset: Result[], unsettled?: { cycle: number, changes: Result[] } }> {
+        const lineages: { origin?: SourceFile, latest?: SourceFile }[] = sources.map(s => ({origin: s, latest: s}));
+        const changesetOf = () => lineages.map(({origin, latest}) => new Result(origin, latest));
+        let changeset: Result[] | undefined;
+        let cyclesThatMadeChanges = 0;
+        for (let cycle = 1; cycle <= cycles; cycle++) {
+            const live = lineages.filter(l => l.latest).map(l => l.latest!);
+            const ctx = cycle === 1 ? this.recipeExecutionContext : this.laterRunContext();
+            const changes = (await scheduleRun(this.recipe, live, ctx)).changeset.filter(r => r.before !== r.after);
+            if (changes.length === 0) {
+                break;
+            }
+            if (changeset) {
+                return {changeset, unsettled: {cycle, changes}};
+            }
+            cyclesThatMadeChanges++;
+            for (const {before, after} of changes) {
+                const lineage = before && lineages.find(l => l.latest === before);
+                if (lineage) {
+                    lineage.latest = after;
+                } else {
+                    lineages.push({latest: after});
+                }
+            }
+            if (cycle >= expectedCycles) {
+                changeset = changesetOf();
+            }
+        }
+        if (cyclesThatMadeChanges < expectedCycles && expectedCycles > 1) {
+            throw new Error(`Expected recipe to complete in ${pluralCycles(expectedCycles)}, ` +
+                `but it settled after ${pluralCycles(cyclesThatMadeChanges)}. Lower expectedCyclesThatMakeChanges.`);
+        }
+        return {changeset: changeset ?? changesetOf()};
+    }
+
+    /** Data tables are written by the first cycle only, as in Java. */
+    private laterRunContext(): ExecutionContext {
+        const messages = {...this.recipeExecutionContext.messages};
+        delete messages[DATA_TABLE_STORE];
+        return new ExecutionContext(messages);
+    }
+
+    private async expectNoFurtherChanges(changes: Result[], headline: string, sanitized: boolean = false) {
+        const print = (sourceFile: SourceFile) => sanitized ? printSanitized(sourceFile) : TreePrinters.print(sourceFile);
+        const found: string[] = [];
+        for (const {before, after} of changes) {
+            if (!before) {
+                found.push(`  ${after!.sourcePath}, which it generated`);
+            } else if (!after) {
+                found.push(`  ${before.sourcePath}, which it deleted`);
+            } else {
+                const [expected, actual] = [await print(before), await print(after)];
+                if (expected !== actual) {
+                    found.push(`  ${after.sourcePath}\nExpected:\n${expected}\n\nActual:\n${actual}`);
+                } else if (!sanitized && !this.allowEmptyDiff) {
+                    found.push(`  ${after.sourcePath}, whose LST it changed without changing the printed source`);
+                }
+            }
+        }
+        if (found.length > 0) {
+            throw new Error([
+                `${headline} the sources again:`,
+                ...found,
+                "A recipe should recognize code it has already changed and leave it alone, so that running it " +
+                "again changes nothing. A recipe that is meant to need more cycles declares how many with " +
+                "expectedCyclesThatMakeChanges."
+            ].join("\n"));
+        }
+    }
+
+    /**
+     * Code that the next run reads is parsed from the printed output, not the LST this run produced, and a
+     * recipe that recognizes its own output only by the shape of that LST changes it again.
+     */
+    private async expectStableOnFreshParse(specs: SourceSpec<any>[], parsed: [SourceSpec<any>, SourceFile][],
+                                           changeset: Result[]) {
+        if (!changeset.some(r => r.before !== r.after)) {
+            return;
+        }
+        const finals = changeset.filter(r => r.after).map(({before, after}): [SourceSpec<any> | undefined, SourceFile] => [
+            before ? parsed.find(([_, sourceFile]) => sourceFile === before)?.[0] :
+                specs.find(s => s.path === after!.sourcePath),
+            after!
+        ]);
+
+        const reparsedByFinal = new Map<SourceFile, SourceFile>();
+        const kinds = new Set(finals.filter(([spec]) => spec).map(([spec]) => spec!.kind));
+        for (const kind of kinds) {
+            const group = finals.filter(([spec]) => spec?.kind === kind);
+            const inputs = [];
+            for (const [_, sourceFile] of group) {
+                inputs.push({text: await printSanitized(sourceFile), sourcePath: sourceFile.sourcePath});
+            }
+            let i = 0;
+            try {
+                for await (const reparsed of group[0][0]!.parser(this.executionContext).parse(...inputs)) {
+                    if (!isParseError(reparsed) && await printSanitized(reparsed) === inputs[i].text) {
+                        // What the source file carries, like its styles, comes from outside its text
+                        reparsedByFinal.set(group[i][1], {...reparsed, markers: group[i][1].markers});
+                    }
+                    i++;
+                }
+            } catch {
+                // files that do not parse again keep the LST the recipe produced
+            }
+        }
+        if (reparsedByFinal.size === 0) {
+            return;
+        }
+
+        const sources = finals.map(([_, sourceFile]) => reparsedByFinal.get(sourceFile) ?? sourceFile);
+        const changes = (await scheduleRun(this.recipe, sources, this.laterRunContext())).changeset
+            .filter(r => r.before !== r.after);
+        await this.expectNoFurtherChanges(changes, "Running the recipe on a fresh parse of its output changed", true);
+    }
+
     private async expectNoParseFailures(parsed: [SourceSpec<any>, SourceFile][]) {
         for (const [_, sourceFile] of parsed) {
             if (sourceFile.kind === ParseErrorKind) {
@@ -291,9 +432,7 @@ export class RecipeSpec {
      */
     private async freshParsePlacements(spec: SourceSpec<any>, after: SourceFile): Promise<Set<string>> {
         try {
-            // Without the comments that search results and markup print as
-            const out = new PrintOutputCapture(MarkerPrinter.SANITIZED);
-            const text = await TreePrinters.printer(after).print(after, out);
+            const text = await printSanitized(after);
             const reparsed = await spec.parser(this.executionContext).parseOne({text, sourcePath: after.sourcePath});
             return isParseError(reparsed) ? new Set() : new Set(markerPlacements(reparsed).keys());
         } catch {
@@ -420,6 +559,15 @@ class ValidateWhitespaceVisitor extends JavaScriptVisitor<ExecutionContext> {
     }
 }
 
+/** Without the comments that search results and markup print as. */
+function printSanitized(sourceFile: SourceFile): Promise<string> {
+    return TreePrinters.printer(sourceFile).print(sourceFile, new PrintOutputCapture(MarkerPrinter.SANITIZED));
+}
+
+function pluralCycles(count: number): string {
+    return `${count} cycle${count === 1 ? "" : "s"}`;
+}
+
 /** Markers that report on an LST rather than describe it, which a recipe is free to leave. */
 const reportingMarkerKinds = new Set<string>([
     MarkersKind.SearchResult,