@openrewrite/rewrite 8.92.17 → 8.92.18

package/src/index.ts

@@ -40,12 +40,14 @@ export async function activate(marketplace: RecipeMarketplace): Promise<void> {
         AsyncCallbackInSyncArrayMethod,
         AutoFormat,
         OrderImports,
-        ChangeImport
+        ChangeImport,
+        ChangeMethodTargetToImport
     } = await import("./javascript/recipes/index.js");
     await marketplace.install(AsyncCallbackInSyncArrayMethod, JavaScript);
     await marketplace.install(AutoFormat, JavaScript);
     await marketplace.install(OrderImports, JavaScript);
     await marketplace.install(ChangeImport, JavaScript);
+    await marketplace.install(ChangeMethodTargetToImport, JavaScript);
 
     const {FindDependency, Search} = await import("./javascript/search/index.js");
     await marketplace.install(FindDependency, Search);

package/src/java/formatting-utils.ts

@@ -64,17 +64,18 @@ export function replaceIndentAfterLastNewline(ws: string, newIndent: string): st
     return ws.substring(0, lastNewline + 1) + newIndent;
 }
 
+const isTextComment = (comment: Comment): comment is TextComment => comment.kind === J.Kind.TextComment;
+
 /**
- * Checks if a Space contains any newlines (in whitespace or comment suffixes).
+ * Checks if a Space contains a line terminator. A block comment spanning lines counts as one, as it
+ * does for automatic semicolon insertion.
  */
 export function spaceContainsNewline(space: J.Space | undefined): boolean {
     if (!space) return false;
     if (space.whitespace.includes("\n")) return true;
-    return space.comments.some(c => c.suffix.includes("\n"));
+    return space.comments.some(c => c.suffix.includes("\n") || (isTextComment(c) && c.text.includes("\n")));
 }
 
-const isTextComment = (comment: Comment): comment is TextComment => comment.kind === J.Kind.TextComment;
-
 /**
  * Re-indents a line's leading whitespace when the enclosing construct moves from `oldMargin` to
  * `newMargin`, preserving whatever indentation the line adds beyond the margin.

package/src/java/rpc.ts

@@ -43,6 +43,7 @@ class TypeSender extends TypeVisitor<RpcSendQueue> {
     }
 
     protected async visitVariable(variable: Type.Variable, q: RpcSendQueue): Promise<Type | undefined> {
+        await q.getAndSend(variable, v => v.flags);
         await q.getAndSend(variable, v => v.name);
         await q.getAndSend(variable, v => v.owner ? asRef(v.owner) : undefined, owner => this.visit(owner, q));
         await q.getAndSend(variable, v => asRef(v.type), t => this.visit(t, q));
@@ -169,6 +170,7 @@ class TypeReceiver extends TypeVisitor<RpcReceiveQueue> {
     }
 
     protected async visitVariable(variable: Type.Variable, q: RpcReceiveQueue): Promise<Type | undefined> {
+        variable.flags = await q.receive(variable.flags);
         variable.name = await q.receive(variable.name);
         variable.owner = await q.receive(variable.owner, owner => this.visit(owner, q));
         variable.type = await q.receive(variable.type, t => this.visit(t, q));

package/src/java/tree.ts

@@ -40,6 +40,21 @@ export interface Expression extends J {
     readonly type?: Type;
 }
 
+export namespace Expression {
+    /**
+     * Returns the first expression inside any number of nested parentheses, or the expression itself
+     * when it is not parenthesized.
+     */
+    export function unwrap(expr: Expression): Expression;
+    export function unwrap(expr: Expression | undefined): Expression | undefined;
+    export function unwrap(expr: Expression | undefined): Expression | undefined {
+        while (expr?.kind === J.Kind.Parentheses) {
+            expr = (expr as J.Parentheses<Expression>).tree.element;
+        }
+        return expr;
+    }
+}
+
 export interface MethodCall extends Expression {
     readonly methodType?: Type.Method;
 }

package/src/java/type.ts

@@ -108,6 +108,7 @@ export namespace Type {
 
     export interface Variable extends Type {
         readonly kind: typeof Kind.Variable;
+        flags: number;
         name: string;
         owner?: Type;
         type: Type;
@@ -137,7 +138,7 @@ export namespace Type {
         }
     }
 
-    export interface Array extends Type, FullyQualified {
+    export interface Array extends Type {
         readonly kind: typeof Kind.Array;
         elemType: Type;
         annotations: Type.Annotation[];
@@ -290,7 +291,6 @@ export namespace Type {
             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
         );
     }
@@ -316,6 +316,23 @@ export namespace Type {
         }
     }
 
+    /**
+     * Whether `matches` accepts the fully qualified name of `type` or, with `matchOverride`, of a
+     * class or interface it extends.
+     */
+    export function isOfTypeWithName(type: Type | undefined, matchOverride: boolean,
+                                     matches: (fullyQualifiedName: string) => boolean): boolean {
+        if (!isFullyQualified(type)) {
+            return false;
+        }
+        if (matches(FullyQualified.getFullyQualifiedName(type))) {
+            return true;
+        }
+        const c = isParameterized(type) ? type.type : type;
+        return matchOverride && isClass(c) &&
+            (isOfTypeWithName(c.supertype, true, matches) || c.interfaces.some(i => isOfTypeWithName(i, true, matches)));
+    }
+
     // Track type variable names and parameterized types to prevent infinite recursion
     let typeVariableNameStack: Set<string> | null = null;
     let parameterizedStack: Set<Type> | null = null;