@openrewrite/rewrite 8.62.3 → 8.62.5

package/src/javascript/parser.ts

@@ -57,6 +57,19 @@ export interface JavaScriptParserOptions extends ParserOptions {
     sourceFileCache?: Map<string, ts.SourceFile>
 }
 
+function getScriptKindFromFileName(fileName: string): ts.ScriptKind {
+    const ext = fileName.toLowerCase();
+    if (ext.endsWith('.tsx')) return ts.ScriptKind.TSX;
+    if (ext.endsWith('.jsx')) return ts.ScriptKind.JSX;
+    if (ext.endsWith('.ts')) return ts.ScriptKind.TS;
+    if (ext.endsWith('.js')) return ts.ScriptKind.JS;
+    if (ext.endsWith('.mjs')) return ts.ScriptKind.JS;
+    if (ext.endsWith('.cjs')) return ts.ScriptKind.JS;
+    if (ext.endsWith('.mts')) return ts.ScriptKind.TS;
+    if (ext.endsWith('.cts')) return ts.ScriptKind.TS;
+    return ts.ScriptKind.TS;
+}
+
 export class JavaScriptParser extends Parser {
 
     private readonly compilerOptions: ts.CompilerOptions;
@@ -138,7 +151,9 @@ export class JavaScriptParser extends Parser {
             }
 
             if (sourceText !== undefined) {
-                sourceFile = ts.createSourceFile(fileName, sourceText, languageVersion, true);
+                // Determine script kind based on file extension
+                const scriptKind = getScriptKindFromFileName(fileName);
+                sourceFile = ts.createSourceFile(fileName, sourceText, languageVersion, true, scriptKind);
                 // Cache the SourceFile if it's a dependency
                 if (!input && this.sourceFileCache) {
                     this.sourceFileCache.set(fileName, sourceFile);
@@ -192,7 +207,7 @@ export class JavaScriptParser extends Parser {
 
             try {
                 yield produce(
-                    new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeChecker, this.relativeTo || process.cwd())
+                    new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeChecker)
                         .visit(sourceFile) as SourceFile,
                     draft => {
                         if (this.styles) {
@@ -222,9 +237,8 @@ export class JavaScriptParserVisitor {
     constructor(
         private readonly sourceFile: ts.SourceFile,
         private readonly sourcePath: string,
-        typeChecker: ts.TypeChecker,
-        projectRoot?: string) {
-        this.typeMapping = new JavaScriptTypeMapping(typeChecker, projectRoot);
+        typeChecker: ts.TypeChecker) {
+        this.typeMapping = new JavaScriptTypeMapping(typeChecker);
     }
 
     visit = (node: ts.Node): any => {
@@ -1884,7 +1898,7 @@ export class JavaScriptParserVisitor {
                 function: select,
                 typeParameters: typeArguments,
                 arguments: this.mapCommaSeparatedList(node.getChildren(this.sourceFile).slice(-3)),
-                functionType: this.mapMethodType(node)
+                methodType: this.mapMethodType(node)
             }
         }
     }

package/src/javascript/preconditions.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 {RewriteRpc} from "../rpc";
+import {Recipe} from "../recipe";
+import {UsesMethod, UsesType} from "./search";
+import {ExecutionContext} from "../execution";
+import {TreeVisitor} from "../visitor";
+import {IsSourceFile} from "../search";
+
+export async function hasSourcePath(filePattern: string): Promise<TreeVisitor<any, ExecutionContext>> {
+    return await (await RewriteRpc.get()?.prepareRecipe("org.openrewrite.FindSourceFiles", {
+        filePattern
+    }))?.editor() || new IsSourceFile(filePattern);
+}
+
+export async function usesMethod(methodMatcher: string, matchOverrides: boolean = false): Promise<TreeVisitor<any, ExecutionContext>> {
+    return await (await RewriteRpc.get()?.prepareRecipe("org.openrewrite.java.search.UsesMethod", {
+        methodMatcher,
+        matchOverrides
+    }))?.editor() || new UsesMethod(methodMatcher)
+}
+
+export async function usesType(fullyQualifiedType: string): Promise<TreeVisitor<any, ExecutionContext>> {
+    return await (await RewriteRpc.get()?.prepareRecipe("org.openrewrite.java.search.UsesType", {
+        fullyQualifiedType
+    }))?.editor() || new UsesType(fullyQualifiedType);
+}

package/src/javascript/print.ts

@@ -21,7 +21,7 @@ import {PrintOutputCapture, TreePrinters} from "../print";
 import {Cursor, isTree, Tree} from "../tree";
 import {Comment, emptySpace, J, Statement, TextComment, TrailingComma, TypedTree} from "../java";
 import {findMarker, Marker, Markers} from "../markers";
-import {Generator, DelegatedYield, FunctionDeclaration, NonNullAssertion, Optional, Spread} from "./markers";
+import {DelegatedYield, FunctionDeclaration, Generator, NonNullAssertion, Optional, Spread} from "./markers";
 
 export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
@@ -81,7 +81,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         return statement;
     }
 
-    override async visitStatementExpression(statementExpression: JS.StatementExpression, p: PrintOutputCapture): Promise<J | J | undefined> {
+    override async visitStatementExpression(statementExpression: JS.StatementExpression, p: PrintOutputCapture): Promise<J | undefined> {
         await this.visitSpace(statementExpression.prefix, p);
         await this.visitMarkers(statementExpression.markers, p);
         await this.visit(statementExpression.statement, p);
@@ -1823,7 +1823,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         }
     }
 
-    protected async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: PrintOutputCapture): Promise<J.RightPadded<T>> {
+    public async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: PrintOutputCapture): Promise<J.RightPadded<T>> {
         if (isTree(right.element)) {
             await this.visit(right.element, p);
         }