JavaScript: Fix a few more parser issues

Author: knutwannheden

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

@@ -391,9 +391,10 @@ export async function discoverFiles(projectRoot: string, verbose: boolean = fals
         return files.filter(isAcceptedFile);
     }
 
-    // Filter to accepted file types
+    // Filter to accepted file types that exist on disk
+    // (git ls-files returns deleted files that are still tracked)
     for (const file of trackedFiles) {
-        if (!ignoredFiles.has(file) && isAcceptedFile(file)) {
+        if (!ignoredFiles.has(file) && isAcceptedFile(file) && fs.existsSync(file)) {
             files.push(file);
         }
     }

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

@@ -176,7 +176,7 @@ async function main() {
     program
         .name('rewrite')
         .description('Run OpenRewrite recipes on your codebase')
-        .argument('<recipe>', 'Recipe to run in format "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")')
+        .argument('<recipe>', 'Recipe to run in format "package:recipe" or "path:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice" or "./dist:my-recipe")')
         .argument('[paths...]', 'Files or directories to process (defaults to project root)')
         .option('--apply', 'Apply changes to files (default is dry-run showing diffs)', false)
         .option('-l, --list', 'Only list paths of files that would be changed', false)
@@ -212,6 +212,7 @@ async function main() {
         if (!recipeSpec) {
             console.error(`Invalid recipe format: ${recipeArg}`);
             console.error('Expected format: "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")');
+            console.error('The package can also be a path to a local directory (e.g., "./dist:my-recipe" or "/path/to/recipes:my-recipe")');
             console.error('Or use "builtin:recipe" for built-in recipes (e.g., "builtin:prefer-optional-chain")');
             console.error('Or use "validate-parsing" to check for parse errors and idempotence.');
             process.exit(1);

rewrite-javascript/rewrite/src/index.ts

@@ -35,16 +35,16 @@ export * from "./run";
 
 // register all recipes in this package
 export async function activate(registry: RecipeRegistry): Promise<void> {
-    const {OrderImports} = await import("./recipe/index.js");
     const {ModernizeOctalEscapeSequences, ModernizeOctalLiterals, RemoveDuplicateObjectKeys} = await import("./javascript/migrate/es6/index.js");
     const {ExportAssignmentToExportDefault} = await import("./javascript/migrate/typescript/index.js");
     const {UseObjectPropertyShorthand, PreferOptionalChain, AddParseIntRadix} = await import("./javascript/cleanup/index.js");
-    const {AsyncCallbackInSyncArrayMethod, UpgradeDependencyVersion} = await import("./javascript/recipes/index.js");
+    const {AsyncCallbackInSyncArrayMethod, UpgradeDependencyVersion, OrderImports, ChangeImport} = await import("./javascript/recipes/index.js");
     const {FindDependency} = await import("./javascript/search/index.js");
 
     registry.register(ExportAssignmentToExportDefault);
     registry.register(FindDependency);
     registry.register(OrderImports);
+    registry.register(ChangeImport);
     registry.register(ModernizeOctalEscapeSequences);
     registry.register(ModernizeOctalLiterals);
     registry.register(RemoveDuplicateObjectKeys);

rewrite-javascript/rewrite/src/javascript/parser.ts

@@ -367,26 +367,53 @@ export class JavaScriptParserVisitor {
         }
 
         let shebangStatement: J.RightPadded<JS.Shebang> | undefined;
+        let shebangTrailingSpace: J.Space | undefined;
         if (prefix.whitespace?.startsWith('#!')) {
             const newlineIndex = prefix.whitespace.indexOf('\n');
             const shebangText = newlineIndex === -1 ? prefix.whitespace : prefix.whitespace.slice(0, newlineIndex);
-            // Include all whitespace after shebang (including blank lines) in the shebang's after space
-            const afterShebang = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex);
+            // Shebang's after only contains the newline that terminates the shebang line
+            // The remaining whitespace and comments go into the first statement's prefix
+            const afterShebangNewline = newlineIndex === -1 ? '' : '\n';
+            const remainingWhitespace = newlineIndex === -1 ? '' : prefix.whitespace.slice(newlineIndex + 1);
 
             shebangStatement = this.rightPadded<JS.Shebang>({
                 kind: JS.Kind.Shebang,
                 id: randomId(),
                 prefix: emptySpace,
                 markers: emptyMarkers,
                 text: shebangText
-            }, {kind: J.Kind.Space, whitespace: afterShebang, comments: []}, emptyMarkers);
+            }, {kind: J.Kind.Space, whitespace: afterShebangNewline, comments: []}, emptyMarkers);
+
+            // Store the trailing whitespace and comments to prepend to first statement
+            if (remainingWhitespace || prefix.comments.length > 0) {
+                shebangTrailingSpace = {kind: J.Kind.Space, whitespace: remainingWhitespace, comments: prefix.comments};
+            }
 
             // CU prefix should be empty when there's a shebang
             prefix = produce(prefix, draft => {
                 draft.whitespace = '';
+                draft.comments = [];
             });
         }
 
+        let statements = this.semicolonPaddedStatementList(node.statements);
+
+        // If there's trailing whitespace/comments after the shebang, prepend to first statement's prefix
+        if (shebangTrailingSpace && statements.length > 0) {
+            const firstStmt = statements[0];
+            statements = [
+                produce(firstStmt, draft => {
+                    const existingPrefix = draft.element.prefix;
+                    draft.element.prefix = {
+                        kind: J.Kind.Space,
+                        whitespace: shebangTrailingSpace!.whitespace + existingPrefix.whitespace,
+                        comments: [...shebangTrailingSpace!.comments, ...existingPrefix.comments]
+                    };
+                }),
+                ...statements.slice(1)
+            ];
+        }
+
         return {
             kind: JS.Kind.CompilationUnit,
             id: randomId(),
@@ -396,8 +423,8 @@ export class JavaScriptParserVisitor {
             charsetName: bomAndTextEncoding.encoding,
             charsetBomMarked: bomAndTextEncoding.hasBom,
             statements: shebangStatement
-                ? [shebangStatement, ...this.semicolonPaddedStatementList(node.statements)]
-                : this.semicolonPaddedStatementList(node.statements),
+                ? [shebangStatement, ...statements]
+                : statements,
             eof: this.prefix(node.endOfFileToken)
         };
     }
@@ -3788,15 +3815,29 @@ export class JavaScriptParserVisitor {
     }
 
     visitJsxExpression(node: ts.JsxExpression): JSX.EmbeddedExpression {
+        let expr: Expression;
+        if (node.expression) {
+            if (node.dotDotDotToken) {
+                expr = produce(this.convert<Expression>(node.expression), draft => {
+                    draft.markers.markers.push({
+                        kind: JS.Markers.Spread,
+                        id: randomId(),
+                        prefix: this.prefix(node.dotDotDotToken!)
+                    } satisfies Spread as Spread);
+                });
+            } else {
+                expr = this.convert<Expression>(node.expression);
+            }
+        } else {
+            expr = this.newEmpty();
+        }
         return {
             kind: JS.Kind.JsxEmbeddedExpression,
             id: randomId(),
             prefix: this.prefix(node),
             markers: emptyMarkers,
             expression: this.rightPadded(
-                node.expression ?
-                    this.convert<Expression>(node.expression) :
-                    this.newEmpty(),
+                expr,
                 this.prefix(this.findChildNode(node, ts.SyntaxKind.CloseBraceToken)!)
             )
         };