@openrewrite/rewrite 8.69.0-20251207-092603 → 8.69.0-20251207-135957

package/src/cli/rewrite.ts

@@ -37,17 +37,19 @@ import {
 } from './cli-utils';
 import {ValidateParsingRecipe} from './validate-parsing-recipe';
 
-const isTTY = process.stdout.isTTY ?? false;
+const isTTY = process.stderr.isTTY ?? false;
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
 class Spinner {
     private frameIndex = 0;
     private interval: NodeJS.Timeout | null = null;
     private message = '';
+    private running = false;
 
     start(message: string): void {
         if (!isTTY) return;
         this.message = message;
+        this.running = true;
         this.render();
         this.interval = setInterval(() => this.render(), 80);
     }
@@ -61,16 +63,34 @@ class Spinner {
     private render(): void {
         const frame = SPINNER_FRAMES[this.frameIndex];
         this.frameIndex = (this.frameIndex + 1) % SPINNER_FRAMES.length;
-        process.stdout.write(`\r\x1b[K${frame} ${this.message}`);
+        process.stderr.write(`\r\x1b[K${frame} ${this.message}`);
+    }
+
+    /**
+     * Temporarily clear the spinner line for other output.
+     * Call resume() to restore it.
+     */
+    clear(): void {
+        if (!isTTY || !this.running) return;
+        process.stderr.write('\r\x1b[K');
+    }
+
+    /**
+     * Resume the spinner after clear().
+     */
+    resume(): void {
+        if (!isTTY || !this.running) return;
+        this.render();
     }
 
     stop(): void {
+        this.running = false;
         if (this.interval) {
             clearInterval(this.interval);
             this.interval = null;
         }
         if (isTTY) {
-            process.stdout.write('\r\x1b[K');
+            process.stderr.write('\r\x1b[K');
         }
     }
 }
@@ -182,14 +202,10 @@ async function main() {
     }
 
     // Handle special built-in recipes
-    let recipe: Recipe;
-    let validateParsingRecipe: ValidateParsingRecipe | undefined;
+    let recipe: Recipe | undefined;
+    const isValidateParsing = recipeArg === 'validate-parsing';
 
-    if (recipeArg === 'validate-parsing') {
-        // Special recipe to validate parsing and check idempotence
-        validateParsingRecipe = new ValidateParsingRecipe();
-        recipe = validateParsingRecipe;
-    } else {
+    if (!isValidateParsing) {
         // Parse recipe specification
         const recipeSpec = parseRecipeSpec(recipeArg);
         if (!recipeSpec) {
@@ -234,10 +250,10 @@ async function main() {
             process.exit(1);
         }
         recipe = foundRecipe;
-    }
 
-    if (opts.verbose) {
-        console.log(`Running recipe: ${recipe.name}`);
+        if (opts.verbose) {
+            console.log(`Running recipe: ${recipe.name}`);
+        }
     }
 
     const spinner = new Spinner();
@@ -309,9 +325,20 @@ async function main() {
         console.log(`Found ${uniqueSourceFiles.length} source files`);
     }
 
-    // Set project root for validate-parsing recipe if active
-    if (validateParsingRecipe) {
-        validateParsingRecipe.setProjectRoot(projectRoot);
+    // Create validate-parsing recipe now that we know the project root
+    if (isValidateParsing) {
+        const validateRecipe = new ValidateParsingRecipe({projectRoot});
+        // Set up reporting callback that coordinates with spinner
+        validateRecipe.onReport = (message: string) => {
+            if (!opts.verbose) {
+                spinner.clear();
+            }
+            console.log(message);
+            if (!opts.verbose) {
+                spinner.resume();
+            }
+        };
+        recipe = validateRecipe;
     }
 
     // Create streaming parser - files are parsed on-demand as they're consumed
@@ -337,7 +364,7 @@ async function main() {
         spinner.start(`Processing ${totalFiles} files...`);
     }
 
-    for await (const result of scheduleRunStreaming(recipe, sourceFileStream, ctx, onProgress)) {
+    for await (const result of scheduleRunStreaming(recipe!, sourceFileStream, ctx, onProgress)) {
         processedCount++;
         const currentPath = result.after?.sourcePath ?? result.before?.sourcePath ?? '';
 
@@ -405,11 +432,11 @@ async function main() {
     if (!opts.verbose) spinner.stop();
 
     // For validate-parsing recipe, check for errors and exit accordingly
-    if (validateParsingRecipe) {
-        if (!validateParsingRecipe.hasErrors) {
+    if (recipe instanceof ValidateParsingRecipe) {
+        if (!recipe.hasErrors) {
             console.log('All files parsed successfully.');
         }
-        process.exit(validateParsingRecipe.hasErrors ? 1 : 0);
+        process.exit(recipe.hasErrors ? 1 : 0);
     }
 
     if (changeCount === 0) {

package/src/cli/validate-parsing-recipe.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Recipe} from '../recipe';
+import {Option, Recipe} from '../recipe';
 import {TreeVisitor} from '../visitor';
 import {ExecutionContext} from '../execution';
 import {SourceFile, Tree} from '../tree';
@@ -24,6 +24,12 @@ import {createTwoFilesPatch} from 'diff';
 import * as fs from 'fs';
 import * as path from 'path';
 
+/**
+ * Callback for reporting validation results.
+ * @param message The message to report
+ */
+export type ReportCallback = (message: string) => void;
+
 /**
  * A recipe that validates parsing by:
  * 1. Reporting parse errors to stderr
@@ -36,13 +42,27 @@ export class ValidateParsingRecipe extends Recipe {
     displayName = 'Validate parsing';
     description = 'Validates that all source files parse correctly and that parse-to-print is idempotent. Reports parse errors and shows diffs for idempotence failures.';
 
-    private projectRoot: string = process.cwd();
+    @Option({
+        displayName: 'Project root',
+        description: 'The root directory of the project, used to resolve source file paths for idempotence checking.',
+        required: false
+    })
+    projectRoot!: string;
+
+    /**
+     * Optional callback for reporting messages. If not set, uses console.log.
+     */
+    onReport?: ReportCallback;
+
     private parseErrorCount = 0;
     private idempotenceFailureCount = 0;
 
-    setProjectRoot(root: string): this {
-        this.projectRoot = root;
-        return this;
+    private report(message: string): void {
+        if (this.onReport) {
+            this.onReport(message);
+        } else {
+            console.log(message);
+        }
     }
 
     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
@@ -59,7 +79,7 @@ export class ValidateParsingRecipe extends Recipe {
                         m => m.kind === MarkersKind.ParseExceptionResult
                     ) as ParseExceptionResult | undefined;
                     const message = parseException?.message ?? 'Unknown parse error';
-                    console.error(`Parse error in ${sourceFile.sourcePath}: ${message}`);
+                    recipe.report(`Parse error in ${sourceFile.sourcePath}: ${message}`);
                     recipe.parseErrorCount++;
                     return tree as R;
                 }
@@ -72,7 +92,7 @@ export class ValidateParsingRecipe extends Recipe {
 
                     if (printed !== original) {
                         recipe.idempotenceFailureCount++;
-                        console.error(`Parse-to-print idempotence failure in ${sourceFile.sourcePath}:`);
+                        recipe.report(`Parse-to-print idempotence failure in ${sourceFile.sourcePath}:`);
 
                         // Generate and print diff
                         const diff = createTwoFilesPatch(
@@ -84,11 +104,11 @@ export class ValidateParsingRecipe extends Recipe {
                             'printed',
                             {context: 3}
                         );
-                        console.error(diff);
+                        recipe.report(diff);
                     }
                 } catch (e: any) {
                     recipe.idempotenceFailureCount++;
-                    console.error(`Failed to check idempotence for ${sourceFile.sourcePath}: ${e.message}`);
+                    recipe.report(`Failed to check idempotence for ${sourceFile.sourcePath}: ${e.message}`);
                 }
 
                 return tree as R;
@@ -98,12 +118,12 @@ export class ValidateParsingRecipe extends Recipe {
 
     async onComplete(_ctx: ExecutionContext): Promise<void> {
         if (this.parseErrorCount > 0 || this.idempotenceFailureCount > 0) {
-            console.error('');
+            this.report('');
             if (this.parseErrorCount > 0) {
-                console.error(`${this.parseErrorCount} file(s) had parse errors.`);
+                this.report(`${this.parseErrorCount} file(s) had parse errors.`);
             }
             if (this.idempotenceFailureCount > 0) {
-                console.error(`${this.idempotenceFailureCount} file(s) had parse-to-print idempotence failures.`);
+                this.report(`${this.idempotenceFailureCount} file(s) had parse-to-print idempotence failures.`);
             }
         }
     }

package/src/javascript/cleanup/use-object-property-shorthand.ts

@@ -21,6 +21,7 @@ import {JavaScriptVisitor} from "../visitor";
 import {J} from "../../java";
 import {JS} from "../tree";
 import {produce} from "immer";
+import {findMarker} from "../../markers";
 
 /**
  * Simplifies object properties where the key and value have the same name,
@@ -121,7 +122,13 @@ export class UseObjectPropertyShorthand extends Recipe {
 
                             // Check if the initializer is also an identifier with the same name
                             if (prop.initializer?.kind === J.Kind.Identifier) {
-                                const initName = (prop.initializer as J.Identifier).simpleName;
+                                const init = prop.initializer as J.Identifier;
+                                const initName = init.simpleName;
+
+                                // Skip if initializer has non-null assertion marker
+                                if (findMarker(init, JS.Markers.NonNullAssertion)) {
+                                    return stmt;
+                                }
 
                                 if (propName === initName) {
                                     hasChanges = true;

package/src/javascript/parser.ts

@@ -370,8 +370,8 @@ export class JavaScriptParserVisitor {
         if (prefix.whitespace?.startsWith('#!')) {
             const newlineIndex = prefix.whitespace.indexOf('\n');
             const shebangText = newlineIndex === -1 ? prefix.whitespace : prefix.whitespace.slice(0, newlineIndex);
-            const afterShebang = newlineIndex === -1 ? '' : '\n';
-            const remainingWhitespace = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex + 1);
+            // Include all whitespace after shebang (including blank lines) in the shebang's after space
+            const afterShebang = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex);
 
             shebangStatement = this.rightPadded<JS.Shebang>({
                 kind: JS.Kind.Shebang,
@@ -381,8 +381,9 @@ export class JavaScriptParserVisitor {
                 text: shebangText
             }, {kind: J.Kind.Space, whitespace: afterShebang, comments: []}, emptyMarkers);
 
+            // CU prefix should be empty when there's a shebang
             prefix = produce(prefix, draft => {
-                draft.whitespace = remainingWhitespace;
+                draft.whitespace = '';
             });
         }
 
@@ -3704,7 +3705,7 @@ export class JavaScriptParserVisitor {
             id: randomId(),
             prefix: this.prefix(node),
             markers: emptyMarkers,
-            openName: this.leftPadded(this.prefix(node.openingElement), this.visit(node.openingElement.tagName)),
+            openName: this.leftPadded(this.prefix(node.openingElement.tagName), this.visit(node.openingElement.tagName)),
             typeArguments: node.openingElement.typeArguments && this.mapTypeArguments(this.suffix(node.openingElement.tagName), node.openingElement.typeArguments),
             afterName: attrs.length === 0 ?
                 this.prefix(this.findLastChildNode(node.openingElement, ts.SyntaxKind.GreaterThanToken)!) :

package/src/javascript/print.ts

@@ -97,7 +97,10 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     override async visitJsxTag(element: JSX.Tag, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(element, p);
-        await this.visitLeftPaddedLocal("<", element.openName, p);
+        // Print < first, then the space after < (openName.before), then the tag name
+        p.append("<");
+        await this.visitSpace(element.openName.before, p);
+        await this.visit(element.openName.element, p);
         if (element.typeArguments) {
             await this.visitContainerLocal("<", element.typeArguments, ",", ">", p);
         }
@@ -113,7 +116,10 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
                 for (let i = 0; i < element.children.length; i++) {
                     await this.visit(element.children[i], p)
                 }
-                await this.visitLeftPaddedLocal("</", element.closingName, p);
+                // Print </ first, then the space after </ (closingName.before), then the tag name
+                p.append("</");
+                await this.visitSpace(element.closingName!.before, p);
+                await this.visit(element.closingName!.element, p);
                 await this.visitSpace(element.afterClosingName, p);
                 p.append(">");
             }

package/src/json/parser.ts

@@ -13,20 +13,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {emptyMarkers} from "../markers";
-import {Parser, ParserInput, ParserSourceReader} from "../parser";
+import {emptyMarkers, markers, MarkersKind, ParseExceptionResult} from "../markers";
+import {Parser, ParserInput, parserInputRead, ParserSourceReader} from "../parser";
 import {randomId} from "../uuid";
 import {SourceFile} from "../tree";
 import {emptySpace, Json, space} from "./tree";
+import {ParseError, ParseErrorKind} from "../parse-error";
 
 export class JsonParser extends Parser {
 
     async *parse(...sourcePaths: ParserInput[]): AsyncGenerator<SourceFile> {
         for (const sourcePath of sourcePaths) {
-            yield {
-                ...new ParseJsonReader(sourcePath).parse(),
-                sourcePath: this.relativePath(sourcePath)
-            };
+            try {
+                yield {
+                    ...new ParseJsonReader(sourcePath).parse(),
+                    sourcePath: this.relativePath(sourcePath)
+                };
+            } catch (e: any) {
+                // Return a ParseError for files that can't be parsed (e.g., JSONC with comments)
+                const text = parserInputRead(sourcePath);
+                const parseError: ParseError = {
+                    kind: ParseErrorKind,
+                    id: randomId(),
+                    markers: markers({
+                        kind: MarkersKind.ParseExceptionResult,
+                        id: randomId(),
+                        parserType: "JsonParser",
+                        exceptionType: e.name || "Error",
+                        message: e.message || "Unknown parse error"
+                    } satisfies ParseExceptionResult as ParseExceptionResult),
+                    sourcePath: this.relativePath(sourcePath),
+                    text
+                };
+                yield parseError;
+            }
         }
     }
 }

package/src/run.ts

@@ -145,7 +145,10 @@ export async function* scheduleRunStreaming(
     } else {
         // For non-scanning recipes, process files immediately as they come in
         const iterable = Array.isArray(before) ? before : before;
+        let processCount = 0;
         for await (const b of iterable) {
+            processCount++;
+            onProgress?.('processing', processCount, -1, b.sourcePath);
             const editedB = await recurseRecipeList(recipe, b, async (recipe, b2) => (await recipe.editor()).visit(b2, ctx, cursor));
             // Always yield a result so the caller knows when each file is processed
             yield new Result(b, editedB !== b ? editedB : b);