@openrewrite/rewrite 8.62.3 → 8.62.5

package/src/javascript/rpc.ts

@@ -18,7 +18,7 @@ import {asRef, RpcCodec, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc"
 import {isJavaScript, JS, JSX} from "./tree";
 import {Expression, J, Statement, Type, TypedTree, TypeTree} from "../java";
 import {createDraft, finishDraft} from "immer";
-import {JavaReceiver, JavaSender} from "../java/rpc";
+import {JavaReceiver, JavaSender, registerJLanguageCodecs} from "../java/rpc";
 import {Cursor, Tree} from "../tree";
 import ComputedPropertyName = JS.ComputedPropertyName;
 
@@ -105,7 +105,7 @@ class JavaScriptSender extends JavaScriptVisitor<RpcSendQueue> {
         await q.getAndSend(functionCall, m => m.function, f => this.visitRightPadded(f, q));
         await q.getAndSend(functionCall, m => m.typeParameters, params => this.visitContainer(params, q));
         await q.getAndSend(functionCall, m => m.arguments, args => this.visitContainer(args, q));
-        await q.getAndSend(functionCall, m => asRef(m.functionType), type => this.visitType(type, q));
+        await q.getAndSend(functionCall, m => asRef(m.methodType), type => this.visitType(type, q));
         return functionCall;
     }
 
@@ -643,7 +643,7 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         draft.function = await q.receive(functionCall.function, select => this.visitRightPadded(select, q));
         draft.typeParameters = await q.receive(functionCall.typeParameters, typeParams => this.visitContainer(typeParams, q));
         draft.arguments = await q.receive(functionCall.arguments, args => this.visitContainer(args, q));
-        draft.functionType = await q.receive(functionCall.functionType, type => this.visitType(type, q) as unknown as Type.Method);
+        draft.methodType = await q.receive(functionCall.methodType, type => this.visitType(type, q) as unknown as Type.Method);
 
         return finishDraft(draft);
     }
@@ -1106,11 +1106,11 @@ class JavaScriptReceiver extends JavaScriptVisitor<RpcReceiveQueue> {
         return this.javaReceiverDelegate.visitRightPadded(right, q)
     }
 
-    protected async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, q: RpcReceiveQueue): Promise<J.LeftPadded<T>> {
+    async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, q: RpcReceiveQueue): Promise<J.LeftPadded<T>> {
         return this.javaReceiverDelegate.visitLeftPadded(left, q);
     }
 
-    protected async visitContainer<T extends J>(container: J.Container<T>, q: RpcReceiveQueue): Promise<J.Container<T>> {
+    async visitContainer<T extends J>(container: J.Container<T>, q: RpcReceiveQueue): Promise<J.Container<T>> {
         return this.javaReceiverDelegate.visitContainer(container, q);
     }
 
@@ -1139,17 +1139,4 @@ class JavaScriptReceiverDelegate extends JavaReceiver {
     }
 }
 
-const javaScriptCodec: RpcCodec<JS> = {
-    async rpcReceive(before: JS, q: RpcReceiveQueue): Promise<JS> {
-        return (await new JavaScriptReceiver().visit(before, q))! as JS;
-    },
-
-    async rpcSend(after: JS, q: RpcSendQueue): Promise<void> {
-        await new JavaScriptSender().visit(after, q);
-    }
-}
-
-// Register codec for all JavaScript AST node types
-Object.values(JS.Kind).forEach(kind => {
-    RpcCodecs.registerCodec(kind, javaScriptCodec);
-});
+registerJLanguageCodecs(JS.Kind.CompilationUnit, new JavaScriptReceiver(), new JavaScriptSender(), JS.Kind);

package/src/javascript/search/index.ts

@@ -0,0 +1,2 @@
+export * from './uses-method';
+export * from './uses-type';

package/src/javascript/search/uses-method.ts

@@ -0,0 +1,21 @@
+import {Expression, J, JavaVisitor} from "../../java";
+import {ExecutionContext} from "../../execution";
+import {MethodMatcher} from "../method-matcher";
+import {JS} from "../tree";
+import {foundSearchResult} from "../../markers";
+
+export class UsesMethod extends JavaVisitor<ExecutionContext> {
+    private readonly matcher;
+
+    constructor(pattern: string) {
+        super();
+        this.matcher = new MethodMatcher(pattern);
+    }
+
+    protected async visitExpression(expression: Expression, p: ExecutionContext): Promise<J | undefined> {
+        if (JS.isMethodCall(expression) && this.matcher.matches(expression.methodType)) {
+            return foundSearchResult(expression);
+        }
+        return super.visitExpression(expression, p);
+    }
+}

package/src/javascript/search/uses-type.ts

@@ -0,0 +1,27 @@
+import {J, JavaVisitor, Type} from "../../java";
+import {ExecutionContext} from "../../execution";
+import * as picomatch from "picomatch";
+import {foundSearchResult} from "../../markers";
+
+export class UsesType extends JavaVisitor<ExecutionContext> {
+    private readonly matcher: picomatch.Matcher;
+
+    constructor(typePattern: string) {
+        super();
+        // Create a picomatch matcher for the pattern
+        this.matcher = picomatch.default ? picomatch.default(typePattern) : (picomatch as any)(typePattern);
+    }
+
+    protected async preVisit(tree: J, _: ExecutionContext): Promise<J | undefined> {
+        if (J.hasType(tree)) {
+            const type = tree.type;
+            if (Type.isFullyQualified(type)) {
+                const fullyQualifiedName = Type.FullyQualified.getFullyQualifiedName(type);
+                if (this.matcher(fullyQualifiedName)) {
+                    return foundSearchResult(tree);
+                }
+            }
+        }
+        return tree;
+    }
+}

package/src/javascript/templating.ts

@@ -92,7 +92,8 @@ export class Pattern {
 export class MatchResult implements Pick<Map<string, J>, "get"> {
     constructor(
         private readonly bindings: Map<string, J> = new Map()
-    ) {}
+    ) {
+    }
 
     get(capture: Capture | string): J | undefined {
         const name = typeof capture === "string" ? capture : capture.name;
@@ -577,7 +578,7 @@ class TemplateApplier {
      * @returns A Promise resolving to the modified AST
      */
     async apply(): Promise<J | undefined> {
-        const {tree, loc, mode} = this.coordinates;
+        const {loc} = this.coordinates;
 
         // Apply the template based on the location and mode
         switch (loc || 'EXPRESSION_PREFIX') {
@@ -771,7 +772,7 @@ class RewriteRuleImpl implements RewriteRule {
  *     after: template`${"left"} === ${"right"}`
  * }));
  */
-export function rewrite<T extends J>(
+export function rewrite(
     builderFn: () => RewriteConfig
 ): RewriteRule {
     const config = builderFn();

package/src/javascript/tree.ts

@@ -17,7 +17,20 @@
  */
 
 import {SourceFile} from "../tree";
-import {Expression, J, NameTree, Statement, Type, TypedTree, TypeTree, VariableDeclarator,} from "../java";
+import {
+    Expression,
+    J,
+    JavaVisitor,
+    MethodCall,
+    NameTree,
+    Statement,
+    Type,
+    TypedTree,
+    TypeTree,
+    VariableDeclarator,
+    registerJavaExtensionKinds
+} from "../java";
+import {JavaScriptVisitor} from "./visitor";
 
 export interface JS extends J {
 }
@@ -94,6 +107,10 @@ export namespace JS {
         WithStatement: "org.openrewrite.javascript.tree.JS$WithStatement",
     } as const;
 
+    export function isMethodCall(e?: Expression): e is MethodCall {
+        return J.isMethodCall(e) || e?.kind === JS.Kind.FunctionCall;
+    }
+
     /**
      * Represents the root of a JavaScript AST (compilation unit).
      * @example // file.js as AST root
@@ -650,12 +667,11 @@ export namespace JS {
      * @example data["key"](5, 0, 4)
      * @example (() => { return 3 + 5 })()
      */
-    export interface FunctionCall extends JS, Expression {
+    export interface FunctionCall extends JS, MethodCall {
         readonly kind: typeof Kind.FunctionCall;
         readonly function?: J.RightPadded<Expression>;
         readonly typeParameters?: J.Container<Expression>;
         readonly arguments: J.Container<Expression>;
-        readonly functionType?: Type.Method;
     }
 
     /**
@@ -901,6 +917,34 @@ export namespace JSX {
 
 const KindValues = new Set(Object.values(JS.Kind));
 
+function javascriptVisitorAdapter<P>(visitor: JavaVisitor<P>): JavaVisitor<P> {
+    const adaptedVisitor = new JavaScriptVisitor<P>();
+
+    // Walk up the prototype chain of the visitor to get all overridden methods
+    let proto = Object.getPrototypeOf(visitor);
+    while (proto && proto !== JavaVisitor.prototype) {
+        Object.getOwnPropertyNames(proto).forEach(name => {
+            const descriptor = Object.getOwnPropertyDescriptor(proto, name);
+            if (descriptor && typeof descriptor.value === 'function' && name !== 'constructor') {
+                // Copy the method, binding it to jsVisitor
+                (adaptedVisitor as any)[name] = descriptor.value.bind(adaptedVisitor);
+            }
+        });
+        proto = Object.getPrototypeOf(proto);
+    }
+
+    // Also copy any instance properties
+    Object.keys(visitor).forEach(key => {
+        if (!(key in adaptedVisitor)) {
+            (adaptedVisitor as any)[key] = (visitor as any)[key];
+        }
+    });
+
+    return adaptedVisitor;
+}
+
+registerJavaExtensionKinds(Object.values(JS.Kind), javascriptVisitorAdapter);
+
 export function isJavaScript(tree: any): tree is JS {
     return KindValues.has(tree["kind"]);
 }