JavaScript: Fix one more annoying formatter bug

Author: knutwannheden

rewrite-javascript/rewrite/src/cli/cli-utils.ts

@@ -452,15 +452,20 @@ export function isAcceptedFile(filePath: string): boolean {
     return false;
 }
 
+export type ProgressCallback = (current: number, total: number, filePath: string) => void;
+
 /**
  * Parse source files using appropriate parsers
  */
 export async function parseFiles(
     filePaths: string[],
     projectRoot: string,
-    verbose: boolean = false
+    verbose: boolean = false,
+    onProgress?: ProgressCallback
 ): Promise<SourceFile[]> {
     const parsed: SourceFile[] = [];
+    const total = filePaths.length;
+    let current = 0;
 
     // Group files by type
     const jsFiles: string[] = [];
@@ -487,6 +492,8 @@ export async function parseFiles(
         }
         const jsParser = new JavaScriptParser({relativeTo: projectRoot});
         for await (const sf of jsParser.parse(...jsFiles)) {
+            current++;
+            onProgress?.(current, total, sf.sourcePath);
             parsed.push(sf);
         }
     }
@@ -498,6 +505,8 @@ export async function parseFiles(
         }
         const pkgParser = new PackageJsonParser({relativeTo: projectRoot});
         for await (const sf of pkgParser.parse(...packageJsonFiles)) {
+            current++;
+            onProgress?.(current, total, sf.sourcePath);
             parsed.push(sf);
         }
     }
@@ -509,6 +518,8 @@ export async function parseFiles(
         }
         const jsonParser = new JsonParser({relativeTo: projectRoot});
         for await (const sf of jsonParser.parse(...jsonFiles)) {
+            current++;
+            onProgress?.(current, total, sf.sourcePath);
             parsed.push(sf);
         }
     }

rewrite-javascript/rewrite/src/cli/rewrite.ts

@@ -34,6 +34,44 @@ import {
     parseRecipeSpec
 } from './cli-utils';
 
+const isTTY = process.stdout.isTTY ?? false;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+class Spinner {
+    private frameIndex = 0;
+    private interval: NodeJS.Timeout | null = null;
+    private message = '';
+
+    start(message: string): void {
+        if (!isTTY) return;
+        this.message = message;
+        this.render();
+        this.interval = setInterval(() => this.render(), 80);
+    }
+
+    update(message: string): void {
+        this.message = message;
+        if (!isTTY) return;
+        this.render();
+    }
+
+    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}`);
+    }
+
+    stop(): void {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        if (isTTY) {
+            process.stdout.write('\r\x1b[K');
+        }
+    }
+}
+
 // Import language modules to register printers
 import '../text';
 import '../json';
@@ -127,9 +165,13 @@ async function main() {
         console.log(`Running recipe: ${recipe.name}`);
     }
 
-    // Discover source files
+    const spinner = new Spinner();
     const projectRoot = process.cwd();
+
+    // Discover source files
+    spinner.start('Discovering source files...');
     const sourceFiles = await discoverFiles(projectRoot, opts.verbose);
+    spinner.stop();
 
     if (sourceFiles.length === 0) {
         console.log('No source files found to process.');
@@ -141,7 +183,11 @@ async function main() {
     }
 
     // Parse all source files
-    const parsedFiles = await parseFiles(sourceFiles, projectRoot, opts.verbose);
+    spinner.start(`Parsing ${sourceFiles.length} files...`);
+    const parsedFiles = await parseFiles(sourceFiles, projectRoot, opts.verbose, (current, total, filePath) => {
+        spinner.update(`Parsing [${current}/${total}] ${filePath}`);
+    });
+    spinner.stop();
 
     if (parsedFiles.length === 0) {
         console.log('No files could be parsed.');
@@ -151,8 +197,18 @@ async function main() {
     // Run the recipe with streaming output
     const ctx = new ExecutionContext();
     let changeCount = 0;
+    let processedCount = 0;
+    const totalFiles = parsedFiles.length;
+
+    spinner.start(`Running recipe on ${totalFiles} files...`);
 
     for await (const result of scheduleRunStreaming(recipe, parsedFiles, ctx)) {
+        processedCount++;
+        const currentPath = result.after?.sourcePath ?? result.before?.sourcePath ?? '';
+        spinner.update(`Processing [${processedCount}/${totalFiles}] ${currentPath}`);
+
+        const statusMsg = `Processing [${processedCount}/${totalFiles}] ${currentPath}`;
+
         if (opts.dryRun) {
             // Print colorized diff immediately (skip empty diffs)
             const diff = await result.diff();
@@ -162,7 +218,9 @@ async function main() {
             );
             if (hasChanges) {
                 changeCount++;
+                spinner.stop();
                 console.log(colorizeDiff(diff));
+                spinner.start(statusMsg);
             }
         } else {
             // Apply changes immediately
@@ -175,20 +233,26 @@ async function main() {
                 await fsp.writeFile(filePath, content);
 
                 changeCount++;
+                spinner.stop();
                 if (result.before) {
                     console.log(`  Modified: ${result.after.sourcePath}`);
                 } else {
                     console.log(`  Created: ${result.after.sourcePath}`);
                 }
+                spinner.start(statusMsg);
             } else if (result.before) {
                 const filePath = path.join(projectRoot, result.before.sourcePath);
                 await fsp.unlink(filePath);
                 changeCount++;
+                spinner.stop();
                 console.log(`  Deleted: ${result.before.sourcePath}`);
+                spinner.start(statusMsg);
             }
         }
     }
 
+    spinner.stop();
+
     if (changeCount === 0) {
         console.log('No changes to make.');
     } else if (opts.dryRun) {

rewrite-javascript/rewrite/src/javascript/format.ts

@@ -1083,9 +1083,9 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
             const parentKind = this.cursor.parent?.value.kind;
             // Skip newline only for object literals (NewClass) - they should preserve single-line formatting
             if (parentKind != J.Kind.NewClass) {
-                if (!draft.end.whitespace.includes("\n")) {
-                    draft.end.whitespace = draft.end.whitespace.replace(/[ \t]+$/, '') + "\n";
-                }
+                draft.end = replaceLastWhitespace(draft.end, ws =>
+                    ws.includes("\n") ? ws : ws.replace(/[ \t]+$/, '') + "\n"
+                );
             }
         });
     }

rewrite-javascript/rewrite/test/javascript/format/format.test.ts

@@ -596,4 +596,22 @@ buf.slice();`
             // @formatter:on
         )
     })
+
+    test('inline comment after last statement in block should stay on same line', () => {
+        return spec.rewriteRun(
+            // @formatter:off
+            //language=typescript
+            typescript(
+                `async function getMarkerOrSkip(fixtureSubDir: string): Promise<NodeResolutionResult> {
+    const marker = await parseAndGetMarker(fixtureSubDir);
+    if (!marker || marker.resolvedDependencies.length === 0) {
+        // Skip test if we couldn't resolve dependencies (CLI not available or packages not installed)
+        return null as any; // Will be caught by the conditional skip
+    }
+    return marker;
+}`
+            )
+            // @formatter:on
+        )
+    })
 });