@openrewrite/rewrite 8.62.3 → 8.62.5

package/src/java/rpc.ts

@@ -20,6 +20,7 @@ import {produceAsync} from "../visitor";
 import {createDraft, Draft, finishDraft, WritableDraft} from "immer";
 import {isTree} from "../tree";
 import {Type} from "./type";
+import Space = J.Space;
 
 export class JavaSender extends JavaVisitor<RpcSendQueue> {
 
@@ -1382,3 +1383,70 @@ export class JavaReceiver extends JavaVisitor<RpcReceiveQueue> {
         return undefined;
     }
 }
+
+export function registerJLanguageCodecs(sourceFileType: string,
+                                        receiver: JavaVisitor<RpcReceiveQueue>,
+                                        sender: JavaVisitor<RpcSendQueue>,
+                                        extendedKinds?: any) {
+    const kinds = new Set([
+        ...Object.values(J.Kind),
+        ...(extendedKinds ? Object.values(extendedKinds) : [])
+    ]);
+
+    // Register codec for all Java AST node types
+    for (const kind of kinds) {
+        if (kind === J.Kind.Space) {
+            RpcCodecs.registerCodec(kind, {
+                async rpcReceive(before: J.Space, q: RpcReceiveQueue): Promise<J.Space> {
+                    return (await receiver.visitSpace(before, q))!;
+                },
+
+                async rpcSend(after: J.Space, q: RpcSendQueue): Promise<void> {
+                    await sender.visitSpace(after, q);
+                }
+            }, sourceFileType);
+        } else if (kind === J.Kind.RightPadded) {
+            RpcCodecs.registerCodec(kind, {
+                async rpcReceive<T extends J | boolean>(before: J.RightPadded<T>, q: RpcReceiveQueue): Promise<J.RightPadded<T>> {
+                    return (await receiver.visitRightPadded(before, q))!;
+                },
+
+                async rpcSend<T extends J | boolean>(after: J.RightPadded<T>, q: RpcSendQueue): Promise<void> {
+                    await sender.visitRightPadded(after, q);
+                }
+            }, sourceFileType);
+        } else if (kind === J.Kind.LeftPadded) {
+            RpcCodecs.registerCodec(kind, {
+                async rpcReceive<T extends J | Space | number | string | boolean>(before: J.LeftPadded<T>, q: RpcReceiveQueue): Promise<J.LeftPadded<T>> {
+                    return (await receiver.visitLeftPadded(before, q))!;
+                },
+
+                async rpcSend<T extends J | Space | number | string | boolean>(after: J.LeftPadded<T>, q: RpcSendQueue): Promise<void> {
+                    await sender.visitLeftPadded(after, q);
+                }
+            }, sourceFileType);
+        } else if (kind === J.Kind.Container) {
+            RpcCodecs.registerCodec(kind, {
+                async rpcReceive<T extends J>(before: J.Container<T>, q: RpcReceiveQueue): Promise<J.Container<T>> {
+                    return (await receiver.visitContainer(before, q))!;
+                },
+
+                async rpcSend<T extends J>(after: J.Container<T>, q: RpcSendQueue): Promise<void> {
+                    await sender.visitContainer(after, q);
+                }
+            }, sourceFileType);
+        } else {
+            RpcCodecs.registerCodec(kind as string, {
+                async rpcReceive(before: J, q: RpcReceiveQueue): Promise<J> {
+                    return (await receiver.visit(before, q))!;
+                },
+
+                async rpcSend(after: J, q: RpcSendQueue): Promise<void> {
+                    await sender.visit(after, q);
+                }
+            }, sourceFileType);
+        }
+    }
+}
+
+registerJLanguageCodecs(J.Kind.CompilationUnit, new JavaReceiver(), new JavaSender());

package/src/java/tree.ts

@@ -17,19 +17,32 @@
  */
 
 import {emptyMarkers, Markers} from "../markers";
-import {SourceFile, Tree, TreeKind} from "../tree";
+import {SourceFile, Tree} from "../tree";
 import {Type} from "./type";
-import {RpcCodec, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
-import {JavaReceiver, JavaSender} from "./rpc";
-import Space = J.Space;
 
 export interface J extends Tree {
     readonly prefix: J.Space;
 }
 
+export namespace J {
+    export function isMethodCall(e?: Expression): e is MethodCall {
+        return e?.kind === J.Kind.NewClass ||
+            e?.kind === J.Kind.MethodInvocation ||
+            e?.kind === J.Kind.MemberReference;
+    }
+
+    export function hasType<T extends J>(tree: T): tree is T & { type: Type } {
+        return tree && 'type' in tree && tree.type != null;
+    }
+}
+
 export interface Expression extends J {
 }
 
+export interface MethodCall extends Expression {
+    readonly methodType?: Type.Method;
+}
+
 export interface TypedTree extends J {
 }
 
@@ -461,13 +474,12 @@ export namespace J {
         readonly codePoint: string;
     }
 
-    export interface MemberReference extends J, Expression {
+    export interface MemberReference extends J, MethodCall {
         readonly kind: typeof Kind.MemberReference;
         readonly containing: RightPadded<Expression>;
         readonly typeParameters?: Container<Expression>;
         readonly reference: LeftPadded<Identifier>;
         readonly type?: Type;
-        readonly methodType?: Type.Method;
         readonly variableType?: Type.Variable;
     }
 
@@ -486,13 +498,12 @@ export namespace J {
         readonly methodType?: Type.Method;
     }
 
-    export interface MethodInvocation extends J, TypedTree, Expression {
+    export interface MethodInvocation extends J, TypedTree, MethodCall {
         readonly kind: typeof Kind.MethodInvocation;
         readonly select?: RightPadded<Expression>;
         readonly typeParameters?: Container<Expression>;
         readonly name: Identifier;
         readonly arguments: Container<Expression>;
-        readonly methodType?: Type.Method;
     }
 
     export interface Modifier extends J {
@@ -539,7 +550,7 @@ export namespace J {
         readonly type?: Type;
     }
 
-    export interface NewClass extends J, TypedTree, Expression {
+    export interface NewClass extends J, TypedTree, MethodCall {
         readonly kind: typeof Kind.NewClass;
         readonly enclosing?: RightPadded<Expression>;
         readonly new: Space;
@@ -817,12 +828,6 @@ export interface DocComment extends Comment {
     // TODO implement me!
 }
 
-const javaKindValues = new Set(Object.values(J.Kind));
-
-export function isJava(tree: any): tree is J {
-    return javaKindValues.has(tree["kind"]);
-}
-
 export function isLiteral(tree: any): tree is J.Literal {
     return tree["kind"] === J.Kind.Literal;
 }
@@ -874,64 +879,3 @@ export namespace TypedTree {
     registerTypeGetter(J.Kind.Wildcard, () => Type.unknownType);
     registerTypeGetter(J.Kind.Unknown, () => Type.unknownType);
 }
-
-const javaReceiver = new JavaReceiver();
-const javaSender = new JavaSender();
-
-const javaCodec: RpcCodec<J> = {
-    async rpcReceive(before: J, q: RpcReceiveQueue): Promise<J> {
-        return (await javaReceiver.visit(before, q))!;
-    },
-
-    async rpcSend(after: J, q: RpcSendQueue): Promise<void> {
-        await javaSender.visit(after, q);
-    }
-}
-
-// Register codec for all Java AST node types
-Object.values(J.Kind).forEach(kind => {
-    if (kind === J.Kind.Space) {
-        RpcCodecs.registerCodec(kind, {
-                async rpcReceive(before: J.Space, q: RpcReceiveQueue): Promise<J.Space> {
-                    return (await javaReceiver.visitSpace(before, q))!;
-                },
-
-                async rpcSend(after: J.Space, q: RpcSendQueue): Promise<void> {
-                    await javaSender.visitSpace(after, q);
-                }
-            }
-        );
-    } else if (kind === J.Kind.RightPadded) {
-        RpcCodecs.registerCodec(kind, {
-            async rpcReceive<T extends J | boolean>(before: J.RightPadded<T>, q: RpcReceiveQueue): Promise<J.RightPadded<T>> {
-                return (await javaReceiver.visitRightPadded(before, q))!;
-            },
-
-            async rpcSend<T extends J | boolean>(after: J.RightPadded<T>, q: RpcSendQueue): Promise<void> {
-                await javaSender.visitRightPadded(after, q);
-            }
-        })
-    } else if (kind === J.Kind.LeftPadded) {
-        RpcCodecs.registerCodec(kind, {
-            async rpcReceive<T extends J | Space | number | string | boolean>(before: J.LeftPadded<T>, q: RpcReceiveQueue): Promise<J.LeftPadded<T>> {
-                return (await javaReceiver.visitLeftPadded(before, q))!;
-            },
-
-            async rpcSend<T extends J | Space | number | string | boolean>(after: J.LeftPadded<T>, q: RpcSendQueue): Promise<void> {
-                await javaSender.visitLeftPadded(after, q);
-            }
-        })
-    } else if (kind === J.Kind.Container) {
-        RpcCodecs.registerCodec(kind, {
-            async rpcReceive<T extends J>(before: J.Container<T>, q: RpcReceiveQueue): Promise<J.Container<T>> {
-                return (await javaReceiver.visitContainer(before, q))!;
-            },
-
-            async rpcSend<T extends J>(after: J.Container<T>, q: RpcSendQueue): Promise<void> {
-                await javaSender.visitContainer(after, q);
-            }
-        })
-    } else {
-        RpcCodecs.registerCodec(kind, javaCodec);
-    }
-});

package/src/java/type.ts

@@ -237,6 +237,10 @@ export namespace Type {
         return type?.kind === Type.Kind.Class;
     }
 
+    export function isMethod(type?: Type): type is Type.Method {
+        return type?.kind === Type.Kind.Method;
+    }
+
     export function isArray(type?: Type): type is Type.Array {
         return type?.kind === Type.Kind.Array;
     }
@@ -245,6 +249,16 @@ export namespace Type {
         return type?.kind === Type.Kind.Parameterized;
     }
 
+    export function isFullyQualified(type?: Type): type is Type.FullyQualified {
+        return type != null && (
+            type.kind === Type.Kind.Class ||
+            type.kind === Type.Kind.Annotation ||
+            type.kind === Type.Kind.Parameterized ||
+            type.kind === Type.Kind.Array ||
+            type.kind === Type.Kind.ShallowClass
+        );
+    }
+
     export interface FullyQualified extends Type {
     }
 

package/src/java/visitor.ts

@@ -16,17 +16,33 @@
 import {Cursor, isTree, SourceFile} from "../tree";
 import {mapAsync} from "../util";
 import {produceAsync, TreeVisitor, ValidImmerRecipeReturnType} from "../visitor";
-import {
-    Expression,
-    isJava,
-    isSpace,
-    J,
-    NameTree,
-    Statement, TypedTree, TypeTree
-} from "./tree";
+import {Expression, isSpace, J, NameTree, Statement, TypedTree, TypeTree} from "./tree";
 import {createDraft, Draft, finishDraft} from "immer";
 import {Type} from "./type";
 
+const javaKindValues = new Set(Object.values(J.Kind));
+
+const extendedJavaKinds = new Map<string, <P>(visitor: JavaVisitor<P>) => JavaVisitor<P>>();
+
+/**
+ * Register additional kind values for interfaces that extend J.
+ * This allows isJava to recognize implementations of those interfaces.
+ * @param kinds - Array of kind values to register
+ * @param adapter - Adapter function to transform a JavaVisitor to, for example, a JavaScriptVisitor
+ */
+export function registerJavaExtensionKinds(
+    kinds: readonly string[],
+    adapter: <P>(visitor: JavaVisitor<P>) => JavaVisitor<P>
+): void {
+    for (const kind of kinds) {
+        extendedJavaKinds.set(kind, adapter);
+    }
+}
+
+export function isJava(tree: any): tree is J {
+    return javaKindValues.has(tree["kind"]) || extendedJavaKinds.has(tree["kind"]);
+}
+
 export class JavaVisitor<P> extends TreeVisitor<J, P> {
     // protected javadocVisitor: any | null = null;
 
@@ -45,7 +61,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     // noinspection JSUnusedLocalSymbols
-    protected async visitSpace(space: J.Space, p: P): Promise<J.Space> {
+    public async visitSpace(space: J.Space, p: P): Promise<J.Space> {
         return space;
     }
 
@@ -995,7 +1011,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         return right ? this.visitRightPadded(right, p) : undefined;
     }
 
-    protected async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: P): Promise<J.RightPadded<T>> {
+    public async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: P): Promise<J.RightPadded<T>> {
         return produceAsync<J.RightPadded<T>>(right, async draft => {
             this.cursor = new Cursor(right, this.cursor);
             if (isTree(right.element)) {
@@ -1011,7 +1027,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         return left ? this.visitLeftPadded(left, p) : undefined;
     }
 
-    protected async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T>> {
+    public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T>> {
         return produceAsync<J.LeftPadded<T>>(left, async draft => {
             this.cursor = new Cursor(left, this.cursor);
             draft.before = await this.visitSpace(left.before, p);
@@ -1029,7 +1045,7 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         return container ? this.visitContainer(container, p) : undefined;
     }
 
-    protected async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
+    public async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
         return produceAsync<J.Container<T>>(container, async draft => {
             this.cursor = new Cursor(container, this.cursor);
             draft.before = await this.visitSpace(container.before, p);
@@ -1200,6 +1216,10 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
             case J.Kind.Yield:
                 return this.visitYield(t as J.Yield, p);
             default:
+                const adapter = extendedJavaKinds.get(t.kind)
+                if (adapter) {
+                    return adapter(this).visit(t, p);
+                }
                 return Promise.resolve(t);
         }
     }

package/src/javascript/format.ts

@@ -159,7 +159,7 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         }) as J.ClassDeclaration;
     }
 
-    protected async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
+    public async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
         const ret = await super.visitContainer(container, p) as J.Container<T>;
         return produce(ret, draft => {
             if (draft.elements.length > 1) {
@@ -1088,7 +1088,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         });
     }
 
-    protected async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T>> {
+    public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: P): Promise<J.LeftPadded<T>> {
         const ret = await super.visitLeftPadded(left, p);
         if (ret == undefined) {
             return ret;

package/src/javascript/index.ts

@@ -19,7 +19,11 @@ export * from "./assertions";
 export * from "./parser";
 export * from "./style";
 export * from "./markers";
+export * from "./preconditions";
 export * from "./templating";
+export * from "./method-matcher";
+
+export * from "./remove-import";
 
 import "./print";
 import "./rpc";

package/src/javascript/method-matcher.ts

@@ -0,0 +1,250 @@
+import {Type} from "../java";
+import FullyQualified = Type.FullyQualified;
+
+export class MethodMatcher {
+    private readonly packagePattern: string;
+    private readonly typePattern: string;
+    private readonly methodPattern: string;
+    private readonly argumentPatterns: string[];
+
+    constructor(pattern: string) {
+        // Find the last space before the method spec (which contains parentheses)
+        const firstParenIndex = pattern.indexOf('(');
+        if (firstParenIndex === -1) {
+            throw new Error(`Invalid pattern format: ${pattern} - missing method arguments`);
+        }
+
+        // Find the last space before the opening parenthesis
+        const lastSpaceBeforeParen = pattern.lastIndexOf(' ', firstParenIndex);
+        if (lastSpaceBeforeParen === -1) {
+            throw new Error(`Invalid pattern format: ${pattern}`);
+        }
+
+        const typeSpec = pattern.substring(0, lastSpaceBeforeParen).trim();
+        const methodSpec = pattern.substring(lastSpaceBeforeParen + 1).trim();
+
+        // Parse type specification (package.Type or just Type)
+        // Special case: *..* pattern (any package, any type)
+        if (typeSpec === '*..*') {
+            this.packagePattern = '*..';
+            this.typePattern = '*';
+        } else {
+            const lastDotIndex = typeSpec.lastIndexOf('.');
+            if (lastDotIndex === -1) {
+                this.packagePattern = '*';
+                this.typePattern = typeSpec;
+            } else {
+                // Check if we're splitting a *.. pattern incorrectly
+                const potentialPackage = typeSpec.substring(0, lastDotIndex);
+                if (potentialPackage.endsWith('*..')) {
+                    // Don't split *.. pattern - it should stay together
+                    this.packagePattern = potentialPackage;
+                    this.typePattern = typeSpec.substring(lastDotIndex + 1);
+                } else {
+                    this.packagePattern = potentialPackage;
+                    this.typePattern = typeSpec.substring(lastDotIndex + 1);
+                }
+            }
+        }
+
+        // Parse method specification methodName(args)
+        const methodParenIndex = methodSpec.indexOf('(');
+        if (methodParenIndex === -1 || !methodSpec.endsWith(')')) {
+            throw new Error(`Invalid method specification: ${methodSpec}`);
+        }
+
+        this.methodPattern = methodSpec.substring(0, methodParenIndex);
+        const argsString = methodSpec.substring(methodParenIndex + 1, methodSpec.length - 1);
+
+        // Parse arguments
+        if (argsString.trim() === '..') {
+            this.argumentPatterns = ['..'];
+        } else if (argsString.trim() === '') {
+            this.argumentPatterns = [];
+        } else {
+            this.argumentPatterns = argsString.split(',').map(arg => arg.trim());
+        }
+    }
+
+    matches(method?: Type.Method): boolean {
+        if (!method) {
+            return false;
+        }
+
+        // Extract fully qualified name from declaringType
+        const fullyQualifiedName = FullyQualified.getFullyQualifiedName(method.declaringType);
+
+        // Split fully qualified name into package and type
+        const lastDotIndex = fullyQualifiedName.lastIndexOf('.');
+        const packageName = lastDotIndex === -1 ? '' : fullyQualifiedName.substring(0, lastDotIndex);
+        const typeName = lastDotIndex === -1 ? fullyQualifiedName : fullyQualifiedName.substring(lastDotIndex + 1);
+
+        // Match package
+        if (!this.matchesPackage(packageName)) {
+            return false;
+        }
+
+        // Match type (normalize primitives for matching)
+        const normalizedTypePattern = this.normalizePrimitiveType(this.typePattern);
+        const normalizedTypeName = this.normalizePrimitiveType(typeName);
+        if (!this.matchesPattern(normalizedTypePattern, normalizedTypeName)) {
+            return false;
+        }
+
+        // Match method name
+        if (!this.matchesPattern(this.methodPattern, method.name)) {
+            return false;
+        }
+
+        // Match arguments - convert Type[] to string representations
+        const argStrings = method.parameterTypes.map(type => this.typeToString(type));
+        return this.matchesArguments(argStrings);
+    }
+
+    private typeToString(type: Type): string {
+        switch (type.kind) {
+            case Type.Kind.Primitive:
+                return (type as Type.Primitive).keyword;
+            case Type.Kind.Class:
+                return (type as Type.Class).fullyQualifiedName;
+            case Type.Kind.Parameterized:
+                return FullyQualified.getFullyQualifiedName((type as Type.Parameterized).type);
+            case Type.Kind.Array:
+                const arrayType = type as Type.Array;
+                return this.typeToString(arrayType.elemType) + '[]';
+            case Type.Kind.GenericTypeVariable:
+                return (type as Type.GenericTypeVariable).name;
+            default:
+                return 'unknown';
+        }
+    }
+
+    private matchesPackage(packageName?: string): boolean {
+        const pkg = packageName || '';
+
+        // Handle *..*  pattern (any package including nested)
+        if (this.packagePattern === '*..') {
+            return true;
+        }
+
+        // Handle * pattern (no package or any single-level package)
+        if (this.packagePattern === '*') {
+            return true;
+        }
+
+        // Handle lib.* pattern (lib and any subpackage)
+        if (this.packagePattern.endsWith('.*')) {
+            const prefix = this.packagePattern.slice(0, -2);
+            return pkg === prefix || pkg.startsWith(prefix + '.');
+        }
+
+        // Exact match
+        return pkg === this.packagePattern;
+    }
+
+    private matchesPattern(pattern: string, value: string): boolean {
+        if (pattern === '*') {
+            return true;
+        }
+
+        // Handle patterns with wildcards
+        if (pattern.includes('*')) {
+            // Convert pattern to regex
+            const regexPattern = pattern
+                .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape special chars except *
+                .replace(/\*/g, '.*'); // Replace * with .*
+            const regex = new RegExp(`^${regexPattern}$`);
+            return regex.test(value);
+        }
+
+        return pattern === value;
+    }
+
+    private matchesArguments(args: string[]): boolean {
+        // Handle .. pattern (any arguments)
+        if (this.argumentPatterns.length === 1 && this.argumentPatterns[0] === '..') {
+            return true;
+        }
+
+        // Handle patterns with .. in arguments
+        let patternIndex = 0;
+        let argIndex = 0;
+
+        while (patternIndex < this.argumentPatterns.length && argIndex < args.length) {
+            const pattern = this.argumentPatterns[patternIndex];
+
+            if (pattern === '..') {
+                // If .. is the last pattern, it matches all remaining args
+                if (patternIndex === this.argumentPatterns.length - 1) {
+                    return true;
+                }
+
+                // Otherwise, try to match the next pattern with remaining args
+                const nextPattern = this.argumentPatterns[patternIndex + 1];
+                let matched = false;
+                for (let i = argIndex; i < args.length; i++) {
+                    if (this.matchesArgumentPattern(nextPattern, args[i])) {
+                        argIndex = i + 1;
+                        patternIndex += 2;
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched) {
+                    return false;
+                }
+            } else {
+                if (!this.matchesArgumentPattern(pattern, args[argIndex])) {
+                    return false;
+                }
+                patternIndex++;
+                argIndex++;
+            }
+        }
+
+        // Check if all patterns and arguments are consumed
+        if (patternIndex < this.argumentPatterns.length) {
+            // Allow trailing .. to match zero arguments
+            return patternIndex === this.argumentPatterns.length - 1 &&
+                this.argumentPatterns[patternIndex] === '..';
+        }
+
+        return argIndex === args.length;
+    }
+
+    private matchesArgumentPattern(pattern: string, arg: string): boolean {
+        // Handle type patterns like lib.Array
+        if (pattern.includes('.')) {
+            // Also check if the pattern is a TypeScript primitive class (lib.Number, lib.String, lib.Boolean)
+            const normalizedPattern = this.normalizePrimitiveType(pattern);
+            const normalizedArg = this.normalizePrimitiveType(arg);
+            return normalizedPattern === normalizedArg;
+        }
+
+        // Normalize TypeScript primitive names to match both primitive and class representations
+        const normalizedPattern = this.normalizePrimitiveType(pattern);
+        const normalizedArg = this.normalizePrimitiveType(arg);
+
+        return normalizedPattern === normalizedArg;
+    }
+
+    private normalizePrimitiveType(type: string): string {
+        switch (type) {
+            case 'number':
+            case 'Number':
+            case 'lib.Number':
+            case 'double':
+                return 'Number';
+            case 'string':
+            case 'String':
+            case 'lib.String':
+                return 'String';
+            case 'boolean':
+            case 'Boolean':
+            case 'lib.Boolean':
+                return 'Boolean';
+            default:
+                return type;
+        }
+    }
+}