@openrewrite/rewrite 8.92.17 → 8.92.18

package/src/javascript/method-matcher.ts

@@ -1,13 +1,20 @@
 import {Type} from "../java";
 import FullyQualified = Type.FullyQualified;
 
+/**
+ * Matches a method type against a `<declaring type> <name>(<args>)` pattern.
+ * `REWRITE_JAVASCRIPT_DUMP_TYPES=1` in a test run prints the pattern each call would match.
+ *
+ * With `matchOverrides`, the pattern's type may also be a supertype or interface of the declaring
+ * type, as in Java. A pattern naming a subtype of the declaring type never matches.
+ */
 export class MethodMatcher {
     private readonly packagePattern: string;
     private readonly typePattern: string;
     private readonly methodPattern: string;
     private readonly argumentPatterns: string[];
 
-    constructor(pattern: string) {
+    constructor(pattern: string, private readonly matchOverrides: boolean = false) {
         // Find the last space before the method spec (which contains parentheses)
         const firstParenIndex = pattern.indexOf('(');
         if (firstParenIndex === -1) {
@@ -31,7 +38,9 @@ export class MethodMatcher {
         } else {
             const lastDotIndex = typeSpec.lastIndexOf('.');
             if (lastDotIndex === -1) {
-                this.packagePattern = '*';
+                // As in Java, a type without a package matches only the type in no package, such as
+                // the global `Array` or the module `fs-extra`. `*.Array` matches any package.
+                this.packagePattern = '';
                 this.typePattern = typeSpec;
             } else {
                 // Check if we're splitting a *.. pattern incorrectly
@@ -71,23 +80,7 @@ export class MethodMatcher {
             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)) {
+        if (!this.matchesTargetType(method.declaringType)) {
             return false;
         }
 
@@ -97,11 +90,30 @@ export class MethodMatcher {
         }
 
         // Match arguments - convert Type[] to string representations
-        const argStrings = method.parameterTypes.map(type => this.typeToString(type));
+        const argStrings = method.parameterTypes.map(type => MethodMatcher.typeName(type));
         return this.matchesArguments(argStrings);
     }
 
-    private typeToString(type: Type): string {
+    private matchesTargetType(type: Type | undefined): boolean {
+        const matches = (name: string) => this.matchesTypeName(name);
+        // A call on an untyped receiver declares on the unknown type, which a wildcard pattern
+        // matches by name. Java's matcher has no such case because Java calls are always typed.
+        return type?.kind === Type.Kind.Unknown
+            ? matches(FullyQualified.getFullyQualifiedName(type))
+            : Type.isOfTypeWithName(type, this.matchOverrides, matches);
+    }
+
+    private matchesTypeName(fullyQualifiedName: string): boolean {
+        const lastDotIndex = fullyQualifiedName.lastIndexOf('.');
+        const packageName = lastDotIndex === -1 ? '' : fullyQualifiedName.substring(0, lastDotIndex);
+        const typeName = lastDotIndex === -1 ? fullyQualifiedName : fullyQualifiedName.substring(lastDotIndex + 1);
+
+        return this.matchesPackage(packageName) &&
+            this.matchesPattern(this.normalizePrimitiveType(this.typePattern), this.normalizePrimitiveType(typeName));
+    }
+
+    /** The name an argument pattern compares against a parameter of this type. */
+    static typeName(type: Type): string {
         switch (type.kind) {
             case Type.Kind.Primitive:
                 return (type as Type.Primitive).keyword;
@@ -111,7 +123,7 @@ export class MethodMatcher {
                 return FullyQualified.getFullyQualifiedName((type as Type.Parameterized).type);
             case Type.Kind.Array:
                 const arrayType = type as Type.Array;
-                return this.typeToString(arrayType.elemType) + '[]';
+                return MethodMatcher.typeName(arrayType.elemType) + '[]';
             case Type.Kind.GenericTypeVariable:
                 return (type as Type.GenericTypeVariable).name;
             default:

package/src/javascript/package-name.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2026 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.
+ */
+
+/**
+ * The package a bare module specifier, or a path below `node_modules`, names. Attribution names a
+ * type declared in an installed package after it, so `@scope/pkg/sub` gives `@scope/pkg`.
+ */
+export function packageNameOf(specifier: string): string {
+    const segments = specifier.split('/');
+    return normalizePackageName(segments[0].startsWith('@') && segments.length > 1
+        ? `${segments[0]}/${segments[1]}`
+        : segments[0]);
+}
+
+/**
+ * The specifier consumers import a node_modules package under. A DefinitelyTyped package
+ * `@types/<pkg>` names `<pkg>`, and `@types/testing-library__react` names `@testing-library/react`.
+ * Types reached directly and through a declaration file's path then share one name.
+ */
+function normalizePackageName(packageName: string): string {
+    if (packageName.startsWith('@types/')) {
+        packageName = packageName.substring('@types/'.length);
+        // Decode __ encoding for scoped packages: testing-library__react -> @testing-library/react
+        if (packageName.includes('__')) {
+            const parts = packageName.split('__');
+            if (parts.length === 2) {
+                packageName = `@${parts[0]}/${parts[1]}`;
+            }
+        }
+    }
+    return packageName;
+}

package/src/javascript/preconditions.ts

@@ -68,6 +68,8 @@ export function isVendoredOrBundled(): RecipeRef {
  * ``methodPattern`` follows the OpenRewrite method-pattern syntax:
  * ``<receiver-type> <method-name>(<args>)`` — e.g.
  * ``"*..* tostring(..)"`` or ``"java.util.Collections emptyList()"``.
+ * For a pattern that does not fire, ``REWRITE_JAVASCRIPT_DUMP_TYPES=1`` prints the
+ * declaring type each call got during the test run.
  *
  * Delegates to {@code org.openrewrite.java.search.HasMethod}.
  */
@@ -75,7 +77,7 @@ export function usesMethod(methodPattern: string, matchOverrides: boolean = fals
     return new RecipeRef(
         "org.openrewrite.java.search.HasMethod",
         {methodPattern, matchOverrides},
-        new UsesMethod(methodPattern),
+        new UsesMethod(methodPattern, matchOverrides),
     );
 }
 
@@ -86,13 +88,14 @@ export function usesMethod(methodPattern: string, matchOverrides: boolean = fals
  * {@link UsesType} visitor for in-process evaluation; see
  * {@link hasSourcePath} for the introspection / lazy-evaluation pattern.
  *
- * Delegates to {@code org.openrewrite.java.search.HasType}.
+ * Delegates to {@code org.openrewrite.java.search.HasType}, which matches a type through any class
+ * or interface it extends and reads `checkAssignability` as `UsesType`'s `includeImplicit`.
  */
 export function usesType(fullyQualifiedTypeName: string, checkAssignability: boolean = false): RecipeRef {
     return new RecipeRef(
         "org.openrewrite.java.search.HasType",
         {fullyQualifiedTypeName, checkAssignability},
-        new UsesType(fullyQualifiedTypeName),
+        new UsesType(fullyQualifiedTypeName, {assignable: true, includeImplicit: checkAssignability}),
     );
 }
 
@@ -109,7 +112,7 @@ export function findMethods(methodPattern: string, matchOverrides: boolean = fal
     return new RecipeRef(
         "org.openrewrite.java.search.FindMethods",
         {methodPattern, matchOverrides},
-        new UsesMethod(methodPattern),
+        new UsesMethod(methodPattern, matchOverrides),
     );
 }
 

package/src/javascript/recipes/change-method-target-to-import.ts

@@ -0,0 +1,178 @@
+/*
+ * Copyright 2026 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 {Option, Recipe} from "../../recipe";
+import {TreeVisitor} from "../../visitor";
+import {ExecutionContext} from "../../execution";
+import {check} from "../../preconditions";
+import {emptyMarkers} from "../../markers";
+import {randomId} from "../../uuid";
+import {emptySpace, isIdentifier, J, rightPadded, Type} from "../../java";
+import {JavaScriptVisitor} from "../visitor";
+import {MethodMatcher} from "../method-matcher";
+import {usesMethod} from "../preconditions";
+import {maybeBind, maybeUnbind} from "../binding";
+import {moduleScopeBindings} from "../add-import";
+import {compilationUnitOf, scopeOf} from "../scope";
+
+/**
+ * Moves calls matching a method pattern onto a member imported from a module, such as `jest.fn()`
+ * to `vi.fn()` with `import {vi} from "vitest"`.
+ *
+ * A call through an import of the old target, whether a namespace, default or named import, moves
+ * too, and the import goes once nothing else uses it.
+ */
+export class ChangeMethodTargetToImport extends Recipe {
+    readonly name = "org.openrewrite.javascript.change-method-target-to-import";
+    readonly displayName = "Change method target to an import";
+    readonly description = "Changes the target of calls matching a method pattern to a member imported from a module, " +
+        "adding the import. A CommonJS file changes only where it already requires the target, and an AMD module not at all.";
+
+    @Option({
+        displayName: "Method pattern",
+        description: "A method pattern matching the calls to move, as `<declaring type> <name>(<args>)`.",
+        example: "jest *(..)"
+    })
+    methodPattern!: string;
+
+    @Option({
+        displayName: "Target module",
+        description: "The module the new target is imported from.",
+        example: "vitest"
+    })
+    targetModule!: string;
+
+    @Option({
+        displayName: "Target member",
+        description: "The member of the target module the calls move onto.",
+        example: "vi"
+    })
+    targetMember!: string;
+
+    @Option({
+        displayName: "Target type",
+        description: "The fully-qualified type of the target member, which declares the methods the calls move to. " +
+            "Without it, the moved calls are attributed to an unknown declaring type.",
+        example: "vitest.VitestUtils",
+        required: false
+    })
+    targetType?: string;
+
+    @Option({
+        displayName: "Match on overrides",
+        description: "When enabled, find methods that are overrides of the method pattern.",
+        required: false
+    })
+    matchOverrides?: boolean;
+
+    constructor(options?: {
+        methodPattern?: string;
+        targetModule?: string;
+        targetMember?: string;
+        targetType?: string;
+        matchOverrides?: boolean;
+    }) {
+        super(options);
+    }
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const matcher = new MethodMatcher(this.methodPattern, this.matchOverrides);
+        const module = this.targetModule;
+        const member = this.targetMember;
+        // Named after the specifier, as the parser names a module object.
+        const moduleObject = classNamed(module);
+        const memberType = this.targetType ? classNamed(this.targetType) : Type.unknownType as Type.FullyQualified;
+
+        return check(usesMethod(this.methodPattern, this.matchOverrides), new class extends JavaScriptVisitor<ExecutionContext> {
+            protected override async visitMethodInvocation(method: J.MethodInvocation, ctx: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, ctx) as J.MethodInvocation;
+                if (!matcher.matches(m.methodType)) {
+                    return m;
+                }
+                const select = m.select?.element;
+                if (select !== undefined && !isIdentifier(select)) {
+                    return m;
+                }
+                const oldName = select?.simpleName ?? m.name.simpleName;
+                const cu = compilationUnitOf(this)!;
+                const owner = scopeOf(this.cursor).declaringScope(oldName);
+                const imported = owner === cu ?
+                    moduleScopeBindings(cu).find(b => b.name === oldName && b.module !== undefined) : undefined;
+                if (owner !== undefined && !imported) {
+                    return m;
+                }
+                // A call without a receiver names the member it was imported as, which a default import lacks.
+                const methodName = select || !imported ? m.name.simpleName : imported.member;
+                if (methodName === undefined) {
+                    return m;
+                }
+
+                const name = maybeBind(this, {module, member, onlyIfReferenced: false});
+                if (name === undefined) {
+                    return m;
+                }
+                if (imported) {
+                    maybeUnbind(this, {module: imported.module!, member: imported.member ?? 'default'});
+                }
+
+                const methodType = m.methodType && {...m.methodType, declaringType: memberType};
+                const target: J.Identifier = {
+                    kind: J.Kind.Identifier,
+                    id: randomId(),
+                    prefix: select?.prefix ?? m.name.prefix,
+                    markers: emptyMarkers,
+                    annotations: [],
+                    simpleName: name,
+                    type: memberType,
+                    fieldType: {
+                        kind: Type.Kind.Variable,
+                        name: member,
+                        flags: 0,
+                        owner: moduleObject,
+                        type: memberType,
+                        annotations: []
+                    } as Type.Variable
+                };
+                const moved: J.MethodInvocation = {
+                    ...m,
+                    select: m.select ? {...m.select, element: target} : rightPadded(target, emptySpace),
+                    name: {
+                        ...m.name,
+                        prefix: m.select ? m.name.prefix : emptySpace,
+                        simpleName: methodName,
+                        type: Type.isMethod(m.name.type) ? methodType : m.name.type,
+                        fieldType: m.name.fieldType && {...m.name.fieldType, name: methodName, owner: memberType}
+                    },
+                    methodType
+                };
+                return moved;
+            }
+        }());
+    }
+}
+
+function classNamed(fullyQualifiedName: string): Type.Class {
+    return {
+        kind: Type.Kind.Class,
+        flags: 0,
+        classKind: Type.Class.Kind.Interface,
+        fullyQualifiedName,
+        typeParameters: [],
+        annotations: [],
+        interfaces: [],
+        members: [],
+        methods: []
+    } as Type.Class;
+}

package/src/javascript/recipes/index.ts

@@ -18,4 +18,5 @@ export * from "./async-callback-in-sync-array-method";
 export * from "./auto-format";
 export * from "./order-imports";
 export * from "./change-import";
+export * from "./change-method-target-to-import";
 export * from "./dependencies";