@openrewrite/rewrite 8.96.4 → 8.97.0

package/src/test/probes.ts

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (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://docs.moderne.io/licensing/moderne-source-available-license
+ * <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.
+ */
+import * as path from "path";
+import {Recipe} from "../recipe";
+import {ExecutionContext} from "../execution";
+import {SourceFile} from "../tree";
+import {ACCUMULATOR_LISTENER, scheduleRun} from "../run";
+import {RecipeRunError} from "../visitor";
+import {DATA_TABLE_STORE} from "../data-table";
+import {Marker} from "../markers";
+
+/** Messages that belong to the test's own run. */
+const NOT_COPIED = new Set<string | symbol>([DATA_TABLE_STORE, ACCUMULATOR_LISTENER]);
+
+/**
+ * Probes of recipes that resolve dependencies take seconds each, so a recipe stops being probed in this process once
+ * its probes have taken this long.
+ */
+const TIME_CAP_MS = 20_000;
+
+/** How long each recipe's probes have taken in this process, by {@link timeCapKey}. */
+const PROBE_MS = new Map<string, number>();
+
+/** The probes each recipe class ran, which a process runs once whether they pass or fail. */
+const PROBED = new WeakMap<Function, Set<string>>();
+
+/**
+ * Runs `run`, a probe of the recipe on what `probe` names, unless this process ran that probe before or the recipe's
+ * probes have taken the time cap, and charges the recipe the time it takes.
+ */
+export async function probeOnce(recipe: Recipe, probe: string, run: () => Promise<void>): Promise<void> {
+    if ((PROBE_MS.get(await timeCapKey(recipe)) ?? 0) > TIME_CAP_MS) {
+        return;
+    }
+    let probed = PROBED.get(recipe.constructor);
+    if (!probed) {
+        PROBED.set(recipe.constructor, probed = new Set());
+    }
+    const key = await probeKey(recipe, probe);
+    if (probed.has(key)) {
+        return;
+    }
+    probed.add(key);
+    const start = performance.now();
+    try {
+        await run();
+    } finally {
+        await charge(recipe, performance.now() - start);
+    }
+}
+
+/** Adds `ms` to the time the recipe's probes have taken in this process. */
+export async function charge(recipe: Recipe, ms: number): Promise<void> {
+    const key = await timeCapKey(recipe);
+    PROBE_MS.set(key, (PROBE_MS.get(key) ?? 0) + ms);
+}
+
+/**
+ * What a recipe's probes share a time cap by: its name, and for a recipe with a recipe list its children's keys too,
+ * since a composite a test declares has one name whatever it runs.
+ */
+async function timeCapKey(recipe: Recipe): Promise<string> {
+    let children: Recipe[];
+    try {
+        children = await recipe.recipeList();
+    } catch {
+        return recipe.name;
+    }
+    const keys: string[] = [];
+    for (const child of children) {
+        keys.push(await timeCapKey(child));
+    }
+    return keys.length === 0 ? recipe.name : `${recipe.name}[${keys.join(",")}]`;
+}
+
+async function probeKey(recipe: Recipe, probe: string): Promise<string> {
+    try {
+        return `${JSON.stringify(await recipe.descriptor())}\0${probe}`;
+    } catch {
+        return `${recipe.name}\0${probe}`;
+    }
+}
+
+/** The error the recipe threw when run on `sources` for up to `cycles` cycles, if it threw. */
+export async function thrownBy(recipe: Recipe, sources: SourceFile[], recipeCtx: ExecutionContext,
+                               cycles: number): Promise<{ error: unknown } | undefined> {
+    const messages: { [key: string | symbol]: any } = {};
+    for (const key of Reflect.ownKeys(recipeCtx.messages)) {
+        if (!NOT_COPIED.has(key)) {
+            messages[key] = recipeCtx.messages[key];
+        }
+    }
+    const ctx = new ExecutionContext(messages);
+    let current = sources;
+    try {
+        for (let cycle = 1; cycle <= cycles; cycle++) {
+            const changeset = (await scheduleRun(recipe, current, ctx)).changeset;
+            if (changeset.every(r => r.before === r.after)) {
+                break;
+            }
+            current = changeset.filter(r => r.after).map(r => r.after!);
+        }
+    } catch (error) {
+        return {error};
+    }
+    return undefined;
+}
+
+/**
+ * The error the recipe threw, with the first line of its message and the first frame of its stack, and when that
+ * frame is in a dependency, the first frame that isn't.
+ */
+export function describeThrown(thrown: unknown, indent: string): string {
+    const cause = thrown instanceof RecipeRunError ? thrown.cause : thrown;
+    if (!(cause instanceof Error)) {
+        return `${indent}${String(cause)}`;
+    }
+    const firstLine = cause.message.trim().split("\n")[0];
+    let description = `${indent}${cause.name}${firstLine ? `: ${firstLine.length > 200 ?
+        `${firstLine.substring(0, 200)}...` : firstLine}` : ""}`;
+    const frames = (cause.stack ?? "").split("\n").map(line => line.trim())
+        .filter(line => line.startsWith("at ") && !/\(node:|^at node:|<anonymous>/.test(line))
+        .map(line => line.split(process.cwd() + path.sep).join(""));
+    if (frames.length > 0) {
+        description += `\n${indent}    ${frames[0]}`;
+        const own = frames.find(frame => !frame.includes("node_modules"));
+        if (own && own !== frames[0]) {
+            description += `\n${indent}    ${own}`;
+        }
+    }
+    return description;
+}
+
+/** Reads as " with the markers of the test's source (Autodetect, PrettierStyle)", or as nothing. */
+export function withMarkersOf(markers: Marker[]): string {
+    const kinds = [...new Set(markers.map(m => typeName(m.kind)))];
+    return kinds.length === 0 ? "" : ` with the markers of the test's source (${kinds.join(", ")})`;
+}
+
+/** Reads as "PlainText" or "JS.CompilationUnit". */
+export function typeName(kind: string): string {
+    return kind.replace(/^.*\./, "").replace(/\$/g, ".");
+}

package/src/test/rewrite-test.ts

@@ -19,15 +19,24 @@ import {noopVisitor, TreeVisitor} from "../visitor";
 import {Parser} from "../parser";
 import {MarkerPrinter, PrintOutputCapture, TreePrinters} from "../print";
 import {Cursor, isTree, rootCursor, SourceFile} from "../tree";
-import {Result, scheduleRun} from "../run";
+import {ACCUMULATOR_LISTENER, Result, scheduleRun} from "../run";
 import {mapAsync, trimIndent} from "../util";
 import {isParseError, ParseErrorKind} from "../parse-error";
 import {Marker, Markers, MarkersKind, ParseExceptionResult} from "../markers";
 import {isNamedStyles} from "../style";
 import {JavaScriptVisitor} from "../javascript";
+import {listenToFormatting} from "../javascript/format";
 import {attributionHint, dumpTypesIfRequested} from "../javascript/type-report";
 import {J, Type} from "../java";
 import {DATA_TABLE_STORE, InMemoryDataTableStore} from "../data-table";
+import * as path from "path";
+import {AccumulatorContents} from "./accumulator-contents";
+import {EmptySources} from "./empty-sources";
+import {UnparsedSources} from "./unparsed-sources";
+import {TreeShapes} from "./tree-shapes";
+import {FormattingScope} from "./formatting-scope";
+import {RpcRecipe} from "../rpc/recipe";
+import {DelegatingRecipe} from "../rpc/java-recipe";
 
 export interface SourceSpec<T extends SourceFile> {
     kind: string,
@@ -45,6 +54,11 @@ interface RecipeSpecConfiguration {
     checkParsePrintIdempotence: boolean;
     allowEmptyDiff: boolean;
     checkReportingMarkersOnly: boolean;
+    checkExecutionContextUnchanged: boolean;
+    checkNoEditsInScanningPhase: boolean;
+    checkLightweightAccumulators: boolean;
+    checkParserShapedTrees: boolean;
+    checkMinimalFormatting: boolean;
     cycles?: number;
     expectedCyclesThatMakeChanges?: number;
     recipe: Recipe;
@@ -62,6 +76,33 @@ export class RecipeSpec {
      */
     checkReportingMarkersOnly: boolean = true
 
+    /**
+     * Fails a run whose recipe puts a message on the execution context, which every recipe and source file in a run
+     * shares.
+     */
+    checkExecutionContextUnchanged: boolean = true
+
+    /** Fails a run whose ScanningRecipe's scanner edits a tree, which the scanning phase discards. */
+    checkNoEditsInScanningPhase: boolean = true
+
+    /**
+     * Fails a run whose ScanningRecipe's accumulator keeps a tree, cursor, visitor, execution context, dependency model
+     * or other type given to registerHeavyweight, which would stay in memory all cycle.
+     */
+    checkLightweightAccumulators: boolean = true
+
+    /**
+     * Fails a run whose output holds a node that the source's parser builds differently from the text it prints, such
+     * as a J.Identifier where the parser makes a J.Literal of `null`.
+     */
+    checkParserShapedTrees: boolean = true
+
+    /**
+     * Fails a run whose recipe auto-formats a whole source file or class that existed before the run, instead of only
+     * what it changed.
+     */
+    checkMinimalFormatting: 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
@@ -114,6 +155,11 @@ export class RecipeSpec {
             checkParsePrintIdempotence: this.checkParsePrintIdempotence,
             allowEmptyDiff: this.allowEmptyDiff,
             checkReportingMarkersOnly: this.checkReportingMarkersOnly,
+            checkExecutionContextUnchanged: this.checkExecutionContextUnchanged,
+            checkNoEditsInScanningPhase: this.checkNoEditsInScanningPhase,
+            checkLightweightAccumulators: this.checkLightweightAccumulators,
+            checkParserShapedTrees: this.checkParserShapedTrees,
+            checkMinimalFormatting: this.checkMinimalFormatting,
             cycles: this.cycles,
             expectedCyclesThatMakeChanges: this.expectedCyclesThatMakeChanges,
             recipe: this.recipe,
@@ -217,21 +263,43 @@ export class RecipeSpec {
         }
 
         this.recipeExecutionContext.messages[DATA_TABLE_STORE] = new InMemoryDataTableStore();
+        this.recipeExecutionContext.messages[ExecutionContext.SCANNING_MUTATION_VALIDATION] =
+            this.checkNoEditsInScanningPhase;
+        const accumulatorContents = this.checkLightweightAccumulators ? new AccumulatorContents() : undefined;
+        this.recipeExecutionContext.messages[ACCUMULATOR_LISTENER] = accumulatorContents?.listener;
+        const contextWrites = this.checkExecutionContextUnchanged ? new ExecutionContextWrites() : undefined;
+        const runContext = (ctx: ExecutionContext) => contextWrites?.watch(ctx) ?? ctx;
         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);
+        const formattingScope = this.checkMinimalFormatting ? new FormattingScope(this.recipe) : undefined;
+        const run = () => this.runCycles(allParsed.map(([_, sourceFile]) => sourceFile), cycles, expectedCycles,
+            runContext);
+        const {changeset, unsettled} = formattingScope ? await listenToFormatting(formattingScope, run) : await run();
+        contextWrites?.assertNone(this.recipe);
 
         this.expectNoUnexpectedGeneratedFiles(flattenedSpecs, changeset);
         this.checkReportingMarkersOnly && await this.expectNoAddedMarkers(flattenedSpecs, allParsed, changeset);
+        accumulatorContents?.assertNoneFound();
         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);
+        await formattingScope?.assertFormattedOnlyWhatChanged(changeset);
+        const changed = changeset.some(r => r.before !== r.after);
+        const freshParse = changed && (cycles > expectedCycles || this.checkParserShapedTrees) ?
+            await this.freshParse(flattenedSpecs, allParsed, changeset) : new Map<SourceFile, SourceFile>();
+        this.checkParserShapedTrees && await new TreeShapes(this.recipe).assertParserShaped(changeset, freshParse);
+        cycles > expectedCycles && await this.expectStableOnFreshParse(changeset, freshParse, runContext);
+        contextWrites?.assertNone(this.recipe);
         await this.expectDataTables();
+        if (changeset.some(r => r.before && r.after !== r.before) && await isProbed(this.recipe)) {
+            await new EmptySources(this.recipe, changeset)
+                .assertNoneThrow(allParsed, this.executionContext, this.recipeExecutionContext, cycles);
+            await new UnparsedSources(this.recipe, changeset)
+                .assertNoneThrow(allParsed.map(([_, sourceFile]) => sourceFile), this.recipeExecutionContext, cycles);
+        }
     }
 
     private async expectDataTables() {
@@ -247,7 +315,8 @@ export class RecipeSpec {
         }
     }
 
-    private async runCycles(sources: SourceFile[], cycles: number, expectedCycles: number):
+    private async runCycles(sources: SourceFile[], cycles: number, expectedCycles: number,
+                            runContext: (ctx: ExecutionContext) => ExecutionContext):
         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));
@@ -255,7 +324,7 @@ export class RecipeSpec {
         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 ctx = runContext(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;
@@ -319,14 +388,11 @@ export class RecipeSpec {
     }
 
     /**
-     * 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.
+     * A fresh parse, by the parser of its spec, of the text each source the recipe left prints, parsing the sources
+     * of one kind together so that they can refer to one another. A parser that throws leaves its sources out.
      */
-    private async expectStableOnFreshParse(specs: SourceSpec<any>[], parsed: [SourceSpec<any>, SourceFile][],
-                                           changeset: Result[]) {
-        if (!changeset.some(r => r.before !== r.after)) {
-            return;
-        }
+    private async freshParse(specs: SourceSpec<any>[], parsed: [SourceSpec<any>, SourceFile][],
+                             changeset: Result[]): Promise<Map<SourceFile, SourceFile>> {
         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),
@@ -344,22 +410,39 @@ export class RecipeSpec {
             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++;
+                    reparsedByFinal.set(group[i++][1], reparsed);
                 }
             } catch {
+                // the sources it didn't get to are left out
+            }
+        }
+        return reparsedByFinal;
+    }
+
+    /**
+     * 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(changeset: Result[], freshParse: Map<SourceFile, SourceFile>,
+                                           runContext: (ctx: ExecutionContext) => ExecutionContext) {
+        let reparsedAny = false;
+        const sources: SourceFile[] = [];
+        for (const after of changeset.filter(r => r.after).map(r => r.after!)) {
+            const reparsed = freshParse.get(after);
+            if (reparsed && !isParseError(reparsed) && await printSanitized(reparsed) === await printSanitized(after)) {
+                // What the source file carries, like its styles, comes from outside its text
+                sources.push({...reparsed, markers: after.markers});
+                reparsedAny = true;
+            } else {
                 // files that do not parse again keep the LST the recipe produced
+                sources.push(after);
             }
         }
-        if (reparsedByFinal.size === 0) {
+        if (!reparsedAny) {
             return;
         }
 
-        const sources = finals.map(([_, sourceFile]) => reparsedByFinal.get(sourceFile) ?? sourceFile);
-        const changes = (await scheduleRun(this.recipe, sources, this.laterRunContext())).changeset
+        const changes = (await scheduleRun(this.recipe, sources, runContext(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);
     }
@@ -501,7 +584,7 @@ export class RecipeSpec {
 
     private async expectGeneratedFiles(specs: SourceSpec<any>[], changeset: Result[]) {
         for (const spec of specs) {
-            if (spec.before) {
+            if (spec.before !== null) {
                 continue;
             }
             if (!spec.after) {
@@ -513,7 +596,7 @@ export class RecipeSpec {
     }
 
     private expectNoUnexpectedGeneratedFiles(specs: SourceSpec<any>[], changeset: Result[]) {
-        const expectedPaths = new Set(specs.filter(spec => !spec.before).map(spec => spec.path));
+        const expectedPaths = new Set(specs.filter(spec => spec.before === null).map(spec => spec.path));
         const unexpected = changeset.filter(c => !c.before && c.after && !expectedPaths.has(c.after.sourcePath));
         if (unexpected.length > 0) {
             throw new Error([
@@ -554,7 +637,7 @@ export class RecipeSpec {
         let unnamed = 0;
         const before: [SourceSpec<any>, { text: string, sourcePath: string }][] = [];
         for (const spec of specs) {
-            if (spec.before) {
+            if (spec.before !== null) {
                 const sourcePath = spec.path || `source-${unnamed++}.${spec.ext}`;
                 before.push([spec, {text: dedent(spec.before), sourcePath: sourcePath}]);
             }
@@ -587,6 +670,76 @@ class ValidateWhitespaceVisitor extends JavaScriptVisitor<ExecutionContext> {
     }
 }
 
+/** Whether the framework puts `key` on the execution context of a run itself. */
+function isFrameworkMessage(key: string | symbol): boolean {
+    return key === DATA_TABLE_STORE || key === ExecutionContext.REQUIRE_PRINT_EQUALS_INPUT;
+}
+
+/** Records the messages that a recipe puts on the execution context of its run, with the code that put each. */
+class ExecutionContextWrites {
+    private readonly writes = new Map<string | symbol, string | undefined>();
+
+    /** A view of `ctx` whose messages record what is put on them, and that otherwise acts as `ctx`. */
+    watch(ctx: ExecutionContext): ExecutionContext {
+        const record = (key: string | symbol) => {
+            if (!isFrameworkMessage(key) && !this.writes.has(key)) {
+                this.writes.set(key, callerFrame());
+            }
+        };
+        const messages = new Proxy(ctx.messages, {
+            set(target, key, value) {
+                record(key);
+                return Reflect.set(target, key, value);
+            },
+            defineProperty(target, key, attributes) {
+                record(key);
+                return Reflect.defineProperty(target, key, attributes);
+            }
+        });
+        return Object.create(ctx, {messages: {value: messages, enumerable: true, writable: true}});
+    }
+
+    assertNone(recipe: Recipe): void {
+        if (this.writes.size === 0) {
+            return;
+        }
+        throw new Error([
+            "Keep state that spans source files in a ScanningRecipe's accumulator, and state within one source file " +
+            "in cursor messages, with this.cursor.messages.set(key, value). " +
+            `${recipe.name} put messages on the ExecutionContext, which every recipe and source file in a run ` +
+            "shares, so what it keeps there leaks into the others:",
+            ...[...this.writes].map(([key, frame]) =>
+                `  ${typeof key === "symbol" ? key.toString() : JSON.stringify(key)}${frame ? ` at ${frame}` : ""}`),
+            "A recipe that must change the ExecutionContext opts out with spec.checkExecutionContextUnchanged = false."
+        ].join("\n"));
+    }
+}
+
+/** The first frame of the stack outside the harness and the runtime, relative to the working directory. */
+function callerFrame(): string | undefined {
+    const frame = (new Error().stack ?? "").split("\n").slice(1)
+        .map(line => line.trim().replace(/^at (async )?/, ""))
+        .find(line => !/[\\/]test[\\/]rewrite-test\.[jt]s:|<anonymous>|^node:/.test(line));
+    return frame?.split(process.cwd() + path.sep).join("");
+}
+
+/**
+ * Whether the recipe is run on sources the test doesn't give it, which a recipe isn't when it or one in its recipe list
+ * is the harness's stand-in for a visitor, or runs in Java, whose harness probes it.
+ */
+async function isProbed(recipe: Recipe): Promise<boolean> {
+    if (recipe instanceof NoopRecipe || recipe instanceof AdHocRecipe || recipe instanceof RpcRecipe ||
+        recipe instanceof DelegatingRecipe) {
+        return false;
+    }
+    for (const child of await recipe.recipeList()) {
+        if (!await isProbed(child)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 /** 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));