@openrewrite/rewrite 8.75.1 → 8.75.3

package/src/javascript/format/format.ts

@@ -322,14 +322,14 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
 
     protected async visitImportDeclaration(jsImport: JS.Import, p: P): Promise<J | undefined> {
         const ret = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+        // Mutative detects same-value assignments and returns the original reference
+        // when nothing actually changed, so no guard function is needed.
         return produce(ret, draft => {
             if (draft.importClause) {
-                // Space after 'import' keyword:
-                // - If there's a default import (name), space goes in importClause.prefix
-                // - If typeOnly (import type ...), space goes in importClause.prefix (before 'type')
-                // - If only namedBindings (no default, no type), space goes in namedBindings.prefix (importClause.prefix is empty)
-                const hasDefaultImport = !!draft.importClause.name;
-                draft.importClause.prefix.whitespace = (hasDefaultImport || draft.importClause.typeOnly) ? " " : "";
+                // Space after 'import' keyword always goes on importClause.prefix.
+                // The parser is consistent here: both ImportClause and NamedBindings share
+                // the same trivia span, but ImportClause consumes it first.
+                draft.importClause.prefix.whitespace = " ";
                 if (draft.importClause.name) {
                     // For import equals declarations (import X = Y), use assignment spacing
                     // For regular imports (import X from 'Y'), no space after name
@@ -338,22 +338,22 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                         : "";
                 }
                 if (draft.importClause.namedBindings) {
-                    // Space before namedBindings - always needed
-                    draft.importClause.namedBindings.prefix.whitespace = " ";
+                    const hasDefaultImport = !!draft.importClause.name;
+                    if (hasDefaultImport || draft.importClause.typeOnly) {
+                        draft.importClause.namedBindings.prefix.whitespace = " ";
+                    }
                     if (draft.importClause.namedBindings.kind == JS.Kind.NamedImports) {
                         const ni = draft.importClause.namedBindings as Draft<JS.NamedImports>;
-                        // Check if this is a multi-line import (any element's prefix has a newline)
                         const isMultiLine = ni.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
                         if (!isMultiLine) {
-                            // Single-line: adjust brace spacing
-                            ni.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                            ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                            const braceSpace = this.style.within.es6ImportExportBraces ? " " : "";
+                            ni.elements.elements[0].element.prefix.whitespace = braceSpace;
+                            ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = braceSpace;
                         } else {
                             // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
-                            // If it has only spaces (no newline), it's the space before a trailing comma
-                            const lastAfter = ni.elements.elements[ni.elements.elements.length - 1].after.whitespace;
-                            if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
-                                ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
+                            const lastAfter = ni.elements.elements[ni.elements.elements.length - 1].after;
+                            if (!lastAfter.whitespace.includes("\n") && lastAfter.whitespace.trim() === "") {
+                                lastAfter.whitespace = this.style.other.beforeComma ? " " : "";
                             }
                         }
                     }
@@ -751,6 +751,9 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
 
     protected async visitVariableDeclarations(multiVariable: J.VariableDeclarations, p: P): Promise<J.VariableDeclarations> {
         const v = await super.visitVariableDeclarations(multiVariable, p) as J.VariableDeclarations;
+        if (v.leadingAnnotations.length === 0) {
+            return v;
+        }
         const parent = this.cursor.parentTree()?.value;
         if (parent?.kind === J.Kind.Block) {
             return produce(v, draft => {
@@ -769,6 +772,9 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
 
     protected async visitMethodDeclaration(method: J.MethodDeclaration, p: P): Promise<J.MethodDeclaration> {
         const m = await super.visitMethodDeclaration(method, p) as J.MethodDeclaration;
+        if (m.leadingAnnotations.length === 0) {
+            return m;
+        }
         return produce(m, draft => {
             draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
             if (draft.leadingAnnotations.length > 0) {
@@ -789,21 +795,29 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
         const e = await super.visitElse(elsePart, p) as J.If.Else;
         const hasBody = e.body.element.kind === J.Kind.Block || e.body.element.kind === J.Kind.If;
 
-        return produce(e, draft => {
-            if (hasBody) {
-                const shouldHaveNewline = this.style.ifStatement.elseOnNewLine;
-                const hasNewline = draft.prefix.whitespace.includes("\n");
+        if (!hasBody) {
+            return e;
+        }
+
+        const shouldHaveNewline = this.style.ifStatement.elseOnNewLine;
+        const hasNewline = e.prefix.whitespace.includes("\n");
+        if ((shouldHaveNewline && !hasNewline) || (!shouldHaveNewline && hasNewline)) {
+            return produce(e, draft => {
                 if (shouldHaveNewline && !hasNewline) {
                     draft.prefix.whitespace = "\n" + draft.prefix.whitespace;
-                } else if (!shouldHaveNewline && hasNewline) {
+                } else {
                     draft.prefix.whitespace = "";
                 }
-            }
-        });
+            });
+        }
+        return e;
     }
 
     protected async visitClassDeclaration(classDecl: J.ClassDeclaration, p: P): Promise<J.ClassDeclaration> {
         const j = await super.visitClassDeclaration(classDecl, p) as J.ClassDeclaration;
+        if (j.leadingAnnotations.length === 0) {
+            return j;
+        }
         return produce(j, draft => {
             draft.leadingAnnotations = this.withNewlines(draft.leadingAnnotations);
             if (draft.leadingAnnotations.length > 0) {
@@ -821,61 +835,75 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
 
     protected async visitBlock(block: J.Block, p: P): Promise<J.Block> {
         const b = await super.visitBlock(block, p) as J.Block;
-        return produce(b, draft => {
-            const parentKind = this.cursor.parent?.value.kind;
-
-            // Check if this is a "simple" block (empty or contains only a single J.Empty)
-            const isSimpleBlock = draft.statements.length === 0 ||
-                (draft.statements.length === 1 && draft.statements[0].element.kind === J.Kind.Empty);
+        const parentKind = this.cursor.parent?.value.kind;
 
-            // Helper to format block on one line
-            const formatOnOneLine = () => {
-                // Format as {} - remove any newlines from end whitespace
-                if (draft.end.whitespace.includes("\n")) {
-                    draft.end.whitespace = draft.end.whitespace.replace(/\n\s*/g, "");
-                }
-                // Also remove newlines from statement padding if there's a J.Empty
-                if (draft.statements.length === 1) {
-                    if (draft.statements[0].element.prefix.whitespace.includes("\n")) {
-                        draft.statements[0].element.prefix.whitespace = "";
-                    }
-                    if (draft.statements[0].after.whitespace.includes("\n")) {
-                        draft.statements[0].after.whitespace = "";
-                    }
-                }
-            };
+        // Check if this is a "simple" block (empty or contains only a single J.Empty)
+        const isSimpleBlock = b.statements.length === 0 ||
+            (b.statements.length === 1 && b.statements[0].element.kind === J.Kind.Empty);
 
-            // Object literals and type literals: always format empty ones as {} on single line
-            if (parentKind === J.Kind.NewClass || parentKind === JS.Kind.TypeLiteral) {
-                if (isSimpleBlock) {
-                    formatOnOneLine();
-                }
-                return;
+        // Object literals and type literals: always format empty ones as {} on single line
+        if (parentKind === J.Kind.NewClass || parentKind === JS.Kind.TypeLiteral) {
+            if (isSimpleBlock && this.blockIsMultiLine(b)) {
+                return produce(b, draft => {
+                    this.formatBlockOnOneLine(draft);
+                });
             }
+            return b;
+        }
 
-            if (isSimpleBlock) {
-                // Determine which style option applies based on parent
-                const isMethodOrFunctionBody = parentKind === J.Kind.Lambda ||
-                    parentKind === J.Kind.MethodDeclaration;
-                const keepInOneLine = isMethodOrFunctionBody
-                    ? this.style.keepWhenReformatting.simpleMethodsInOneLine
-                    : this.style.keepWhenReformatting.simpleBlocksInOneLine;
-
-                if (keepInOneLine) {
-                    formatOnOneLine();
-                } else {
-                    // Format with newline between { and }
-                    if (!draft.end.whitespace.includes("\n")) {
-                        draft.end = this.withNewlineSpace(draft.end);
-                    }
+        if (isSimpleBlock) {
+            const isMethodOrFunctionBody = parentKind === J.Kind.Lambda ||
+                parentKind === J.Kind.MethodDeclaration;
+            const keepInOneLine = isMethodOrFunctionBody
+                ? this.style.keepWhenReformatting.simpleMethodsInOneLine
+                : this.style.keepWhenReformatting.simpleBlocksInOneLine;
+
+            if (keepInOneLine) {
+                if (this.blockIsMultiLine(b)) {
+                    return produce(b, draft => {
+                        this.formatBlockOnOneLine(draft);
+                    });
                 }
             } else {
-                // Non-simple blocks: ensure closing brace is on its own line
-                if (!draft.end.whitespace.includes("\n") && !draft.statements[draft.statements.length - 1].after.whitespace.includes("\n")) {
-                    draft.end = this.withNewlineSpace(draft.end);
+                if (!b.end.whitespace.includes("\n")) {
+                    return produce(b, draft => {
+                        draft.end = this.withNewlineSpace(draft.end);
+                    });
                 }
             }
-        });
+        } else {
+            // Non-simple blocks: ensure closing brace is on its own line
+            if (!b.end.whitespace.includes("\n") && !b.statements[b.statements.length - 1].after.whitespace.includes("\n")) {
+                return produce(b, draft => {
+                    draft.end = this.withNewlineSpace(draft.end);
+                });
+            }
+        }
+
+        return b;
+    }
+
+    private blockIsMultiLine(b: J.Block): boolean {
+        if (b.end.whitespace.includes("\n")) return true;
+        if (b.statements.length === 1) {
+            if (b.statements[0].element.prefix.whitespace.includes("\n")) return true;
+            if (b.statements[0].after.whitespace.includes("\n")) return true;
+        }
+        return false;
+    }
+
+    private formatBlockOnOneLine(draft: Draft<J.Block>): void {
+        if (draft.end.whitespace.includes("\n")) {
+            draft.end.whitespace = draft.end.whitespace.replace(/\n\s*/g, "");
+        }
+        if (draft.statements.length === 1) {
+            if (draft.statements[0].element.prefix.whitespace.includes("\n")) {
+                draft.statements[0].element.prefix.whitespace = "";
+            }
+            if (draft.statements[0].after.whitespace.includes("\n")) {
+                draft.statements[0].after.whitespace = "";
+            }
+        }
     }
 
     protected async visitSwitch(aSwitch: J.Switch, p: P): Promise<J | undefined> {
@@ -1100,7 +1128,7 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
         }
     }
 
-    private ensurePrefixHasNewLine<T extends J>(node: Draft<J>) {
+    private ensurePrefixHasNewLine(node: Draft<J>) {
         if (!node.prefix) return;
 
         // Check if newline already exists in the effective last whitespace

package/src/javascript/format/minimum-viable-spacing-visitor.ts

@@ -84,6 +84,7 @@ export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
 
         // Note: typeParameters should NOT have space before them - they immediately follow the class name
         // e.g., "class DataTable<Row>" not "class DataTable <Row>"
+        // Note: body.prefix spacing (space before '{') is handled by SpacesVisitor, not here.
 
         if (c.extends && c.extends.before.whitespace === "") {
             c = produce(c, draft => {
@@ -100,10 +101,6 @@ export class MinimumViableSpacingVisitor<P> extends JavaScriptVisitor<P> {
             });
         }
 
-        c = produce(c, draft => {
-            draft.body.prefix.whitespace = "";
-        });
-
         return c;
     }
 

package/src/javascript/format/whitespace-reconciler.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {isIdentifier, isLiteral, isSpace, J, Type} from '../../java';
+import {isIdentifier, isLiteral, isSpace, J, TextComment, Type} from '../../java';
 import {JS} from "../tree";
 
 /**
@@ -163,7 +163,9 @@ export class WhitespaceReconciler {
 
         // Space nodes - copy when reconciling, don't recurse
         if (isSpace(original)) {
-            return this.shouldReconcile() ? formatted : original;
+            if (!this.shouldReconcile()) return original;
+            if (isSpace(formatted) && this.spacesEqual(original, formatted as J.Space)) return original;
+            return formatted;
         }
 
         // Track entering target subtree (using referential equality)
@@ -247,6 +249,10 @@ export class WhitespaceReconciler {
             // Space values and markers: copy from formatted when reconciling
             if ((isSpace(originalValue)) || key === 'markers') {
                 if (this.shouldReconcile() && formattedValue !== originalValue) {
+                    // For spaces, check structural equality to avoid unnecessary new objects
+                    if (isSpace(originalValue) && isSpace(formattedValue) && this.spacesEqual(originalValue, formattedValue as J.Space)) {
+                        continue;
+                    }
                     result = { ...result, [key]: formattedValue } as VisitableNode;
                 }
                 continue;
@@ -297,6 +303,25 @@ export class WhitespaceReconciler {
         return this.reconcileState === 'reconciling';
     }
 
+    /**
+     * Structurally compare two Space objects for equality.
+     * Currently only TextComment has additional properties (text, multiline);
+     * if new comment types are added, extend the comparison here.
+     */
+    private spacesEqual(a: J.Space, b: J.Space): boolean {
+        if (a.whitespace !== b.whitespace) return false;
+        if (a.comments.length !== b.comments.length) return false;
+        for (let i = 0; i < a.comments.length; i++) {
+            const ca = a.comments[i], cb = b.comments[i];
+            if (ca.kind !== cb.kind || ca.suffix !== cb.suffix) return false;
+            if (ca.kind === J.Kind.TextComment) {
+                const ta = ca as TextComment, tb = cb as TextComment;
+                if (ta.text !== tb.text || ta.multiline !== tb.multiline) return false;
+            }
+        }
+        return true;
+    }
+
     /**
      * Checks if two nodes with different kinds are semantically equivalent.
      * This handles cases like Prettier's quoteProps option which can change

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

@@ -88,6 +88,12 @@ export class OrderImports extends Recipe {
                     return originalImportPosition[aPadded.element.id] - originalImportPosition[bPadded.element.id];
                 });
 
+                // Check if anything actually changed
+                const alreadySorted = sortedSpecifiers.every((s, i) => s === imports[i]);
+                if (alreadySorted) {
+                    return cu;
+                }
+
                 const cuWithImportsSorted = await produceAsync(cu, async draft => {
                     draft.statements = [...sortedSpecifiers, ...restStatements];
                 });

package/src/javascript/remove-import.ts

@@ -1,7 +1,7 @@
 import {JavaScriptVisitor} from "./visitor";
 import {J} from "../java";
 import {JS, JSX} from "./tree";
-import {mapAsync} from "../util";
+import {mapAsync, updateIfChanged} from "../util";
 import {ElementRemovalFormatter} from "../java";
 
 /**
@@ -146,7 +146,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         return this.produceJavaScript(compilationUnit, p, async draft => {
             const formatter = new ElementRemovalFormatter<J>(true); // Preserve file headers from first import
 
-            draft.statements = await mapAsync(compilationUnit.statements, async (stmt) => {
+            const newStatements = await mapAsync(compilationUnit.statements, async (stmt) => {
                 const statement = stmt.element;
 
                 // Handle ES6 imports
@@ -159,7 +159,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                     }
 
                     const finalResult = formatter.processKept(result) as JS.Import;
-                    return {...stmt, element: finalResult};
+                    return updateIfChanged(stmt, {element: finalResult});
                 }
 
                 // Handle CommonJS require statements
@@ -174,7 +174,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                     }
 
                     const finalResult = formatter.processKept(result) as J.VariableDeclarations;
-                    return {...stmt, element: finalResult};
+                    return updateIfChanged(stmt, {element: finalResult});
                 }
 
                 // Handle JS.ScopedVariableDeclarations (multi-variable var/let/const)
@@ -194,7 +194,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                                 varFormatter.markRemoved(varDecl);
                             } else {
                                 const formattedVarDecl = varFormatter.processKept(result as J.VariableDeclarations);
-                                filteredVariables.push({...v, element: formattedVarDecl});
+                                filteredVariables.push(updateIfChanged(v, {element: formattedVarDecl}));
                             }
                         } else {
                             filteredVariables.push(v);
@@ -210,20 +210,21 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                         ? formatter.processKept({...scopedVarDecl, variables: filteredVariables})
                         : formatter.processKept(statement);
 
-                    return {...stmt, element: finalElement};
+                    return updateIfChanged(stmt, {element: finalElement});
                 }
 
                 // For any other statement type, apply prefix from removed elements
                 if (statement) {
                     const finalStatement = formatter.processKept(statement);
-                    return {...stmt, element: finalStatement};
+                    return updateIfChanged(stmt, {element: finalStatement});
                 }
 
                 return stmt;
             });
 
-            // Filter out undefined (removed) statements
-            draft.statements = draft.statements.filter(s => s !== undefined);
+            draft.statements = newStatements.some(s => s === undefined)
+                ? newStatements.filter(s => s !== undefined)
+                : newStatements;
             draft.eof = await this.visitSpace(compilationUnit.eof, p);
         });
     }

package/src/test/rewrite-test.ts

@@ -40,6 +40,7 @@ export interface SourceSpec<T extends SourceFile> {
 
 export class RecipeSpec {
     checkParsePrintIdempotence: boolean = true
+    allowEmptyDiff: boolean = false
 
     recipe: Recipe = new NoopRecipe()
 
@@ -162,9 +163,21 @@ export class RecipeSpec {
 
             if (!spec.after) {
                 if (after && after !== result?.before) {
-                    expect(await TreePrinters.print(after)).toEqual(dedent(spec.before!));
-                    // TODO: Consider throwing an error, as there should typically have been no change to the LST
-                    // fail("Expected after to be undefined.");
+                    const actual = await TreePrinters.print(after);
+                    const expected = dedent(spec.before!);
+                    if (actual === expected) {
+                        if (!this.allowEmptyDiff) {
+                            throw new Error(
+                                "An empty diff was generated. The recipe incorrectly " +
+                                "changed the AST without changing the printed output."
+                            );
+                        }
+                    } else {
+                        throw new Error(
+                            "Expected no change but recipe modified the file.\n" +
+                            `Expected:\n${expected}\n\nActual:\n${actual}`
+                        );
+                    }
                 }
                 if (spec.afterRecipe) {
                     await spec.afterRecipe(matchingSpec![1]);

package/src/visitor.ts

@@ -145,13 +145,18 @@ export abstract class TreeVisitor<T extends Tree, P> {
         const newMarkers = await this.visitMarkers(before.markers, p);
 
         if (recipe) {
-            // Remove markers before Mutative drafting to avoid cycles, then restore after
+            // Remove markers before Mutative drafting to avoid cycles, then restore after.
+            // The spread cost is paid unconditionally, but it enables the identity check below.
             const withoutMarkers = { ...before, markers: emptyMarkers };
             const result = await produceAsync(withoutMarkers, recipe);
             if (result === undefined) {
                 return undefined;
             }
-            // Restore markers (use newMarkers since we visited them)
+            // Mutative's produceAsync returns the same reference when no draft mutations occurred
+            // (structural sharing), so reference equality is a reliable no-change check.
+            if (result === withoutMarkers && newMarkers === before.markers) {
+                return before;
+            }
             return { ...result, markers: newMarkers } as T;
         }
 

package/dist/rewrite-javascript-version.txt

@@ -1 +0,0 @@
-8.75.1