@openrewrite/rewrite 8.92.16 → 8.92.18

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

@@ -7,9 +7,9 @@ import {foundSearchResult} from "../../markers";
 export class UsesMethod extends JavaVisitor<ExecutionContext> {
     private readonly matcher;
 
-    constructor(pattern: string) {
+    constructor(pattern: string, matchOverrides: boolean = false) {
         super();
-        this.matcher = new MethodMatcher(pattern);
+        this.matcher = new MethodMatcher(pattern, matchOverrides);
     }
 
     protected async visitExpression(expression: Expression, p: ExecutionContext): Promise<J | undefined> {

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

@@ -1,27 +1,48 @@
 import {J, JavaVisitor, Type} from "../../java";
+import {JS} from "../tree";
 import {ExecutionContext} from "../../execution";
 import * as picomatch from "picomatch";
 import {foundSearchResult} from "../../markers";
 
+/**
+ * Marks each tree whose type matches a glob pattern.
+ *
+ * With `assignable`, a type also matches through a class or interface it extends. A primitive then
+ * matches by its keyword. With `includeImplicit`, a call also matches through its method's declaring,
+ * return and parameter types.
+ */
 export class UsesType extends JavaVisitor<ExecutionContext> {
     private readonly matcher: picomatch.Matcher;
+    private readonly assignable: boolean;
+    private readonly includeImplicit: boolean;
 
-    constructor(typePattern: string) {
+    constructor(typePattern: string, {assignable = false, includeImplicit = false}: {
+        assignable?: boolean,
+        includeImplicit?: boolean
+    } = {}) {
         super();
-        // Create a picomatch matcher for the pattern
         this.matcher = picomatch.default ? picomatch.default(typePattern) : (picomatch as any)(typePattern);
+        this.assignable = assignable;
+        this.includeImplicit = includeImplicit;
     }
 
     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);
-                }
+        if (J.hasType(tree) && this.matches(tree.type)) {
+            return foundSearchResult(tree);
+        }
+        if (this.includeImplicit && JS.isMethodCall(tree) && tree.methodType) {
+            const method = tree.methodType;
+            if ([method.declaringType, method.returnType, ...method.parameterTypes].some(t => this.matches(t))) {
+                return foundSearchResult(tree);
             }
         }
         return tree;
     }
+
+    private matches(type: Type | undefined): boolean {
+        if (Type.isPrimitive(type)) {
+            return this.assignable && type.keyword !== '' && this.matcher(type.keyword);
+        }
+        return Type.isOfTypeWithName(type, this.assignable, this.matcher);
+    }
 }

package/src/javascript/templating/bindings.ts

@@ -13,64 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {J, Type} from '../../java';
+import {J, NameTree} from '../../java';
 import {JavaScriptVisitor} from '../visitor';
-import {isValueReference} from '../scope';
+import {isReference, scopeOf} from '../scope';
 
 /**
  * Renames the identifiers a template uses for its declared bindings to the names the file
  * actually binds. Runs before parameter substitution, so only the template's own code is in
  * scope and a caller's captured code is never rewritten.
  */
-export async function renameBindings<T extends J>(tree: T, renames: Record<string, string>, modules: Record<string, string>): Promise<T> {
-    return new RenameBindingsVisitor(renames, modules).visit(tree, undefined) as Promise<T>;
+export async function renameBindings<T extends J>(tree: T, renames: Record<string, string>): Promise<T> {
+    return new RenameBindingsVisitor(renames).visit(tree, undefined) as Promise<T>;
 }
 
 class RenameBindingsVisitor extends JavaScriptVisitor<undefined> {
-    constructor(private readonly renames: Record<string, string>,
-                private readonly modules: Record<string, string>) {
+    constructor(private readonly renames: Record<string, string>) {
         super();
     }
 
+    // The class of `Mocked<T>` and a decorator's name sit behind this hook, which the base visitor holds closed
+    protected override async visitTypeName<N extends NameTree>(nameTree: N, p: undefined): Promise<N> {
+        return await this.visit(nameTree, p) as N;
+    }
+
     override async visitIdentifier(identifier: J.Identifier, p: undefined): Promise<J | undefined> {
         const renamed = this.renames[identifier.simpleName];
         if (renamed === undefined || renamed === identifier.simpleName) {
             return identifier;
         }
 
-        // Attribution settles it where the context import resolved. It is absent for a module the
-        // parse could not reach, and the identifier's position decides instead.
-        const resolved = resolvedModule(identifier);
-        const refersToBinding = resolved !== undefined
-            ? resolved === this.modules[identifier.simpleName]
-            : isValueReference(this.cursor, identifier);
+        // Only the context binds at module scope, so a reference nothing in the template rebinds reads it
+        const refersToBinding = isReference(this.cursor, identifier) &&
+            !scopeOf(this.cursor).declares(identifier.simpleName);
 
         return refersToBinding ? {...identifier, simpleName: renamed} as J.Identifier : identifier;
     }
 }
-
-/** The module an identifier's attribution traces back to, following the owning-class chain to its root. */
-function resolvedModule(identifier: J.Identifier): string | undefined {
-    const fieldType = identifier.fieldType;
-    if (fieldType?.kind === Type.Kind.Variable) {
-        const owner = (fieldType as Type.Variable).owner;
-        return owner && Type.isClass(owner) ? rootName(owner as Type.Class) : undefined;
-    }
-    const type = identifier.type;
-    if (type && Type.isMethod(type)) {
-        const declaring = (type as Type.Method).declaringType;
-        return declaring ? rootName(declaring as Type.Class) : undefined;
-    }
-    if (type && Type.isClass(type)) {
-        return rootName(type as Type.Class);
-    }
-    return undefined;
-}
-
-function rootName(classType: Type.Class): string {
-    let current: Type.Class = classType;
-    while (current.owningClass && Type.isClass(current.owningClass)) {
-        current = current.owningClass as Type.Class;
-    }
-    return Type.FullyQualified.getFullyQualifiedName(current);
-}

package/src/javascript/templating/comparator.ts

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Cursor, Markers, Tree} from '../..';
+import {Cursor, Tree} from '../..';
 import {J, Type} from '../../java';
 import {JS} from '../index';
 import {JavaScriptSemanticComparatorVisitor} from '../comparator';
-import {CaptureMarker, CaptureStorageValue, PlaceholderUtils} from './utils';
+import {CaptureMarker, CaptureStorageValue, PlaceholderUtils, TEMPLATE_MODULE} from './utils';
 import {Capture, CaptureConstraintContext, CaptureMap, DebugLogEntry, MatchExplanation} from './types';
 import {CAPTURE_NAME_SYMBOL} from './capture';
 
@@ -54,8 +54,8 @@ export interface MatcherState {
  * Part of Layer 1 (Core Instrumentation).
  */
 export interface MatcherCallbacks {
-    handleCapture: (capture: CaptureMarker, target: J, wrapper?: J.RightPadded<J>) => boolean;
-    handleVariadicCapture: (capture: CaptureMarker, targets: J[], wrappers?: J.RightPadded<J>[]) => boolean;
+    handleCapture: (capture: CaptureMarker, target: J, wrapper?: J.RightPadded<J>) => Promise<boolean>;
+    handleVariadicCapture: (capture: CaptureMarker, targets: J[], wrappers?: J.RightPadded<J>[]) => Promise<boolean>;
     saveState: () => MatcherState;
     restoreState: (state: MatcherState) => void;
 
@@ -175,7 +175,7 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                     }
                 }
 
-                const success = this.matcher.handleCapture(captureMarker, target, undefined);
+                const success = await this.matcher.handleCapture(captureMarker, target, undefined);
                 if (!success) {
                     const captureName = captureMarker.captureName || 'unnamed';
                     return this.captureConflict(captureName) as R;
@@ -194,9 +194,12 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
         return await super.visit(j, p, parent);
     }
 
-    /** A capture in the receiver has to bind, so a matching `methodType` cannot stand in for it. */
-    protected override selectMustBeVisited(method: J.MethodInvocation): boolean {
-        return method.select !== undefined && containsCapture(method.select);
+    /**
+     * A function the pattern's `context` declares lives in no module of the source,
+     * so it stands in for any function of its name.
+     */
+    protected override declaresAnyCallee(declaringType: Type.FullyQualified): boolean {
+        return Type.FullyQualified.getFullyQualifiedName(declaringType) === TEMPLATE_MODULE;
     }
 
     protected hasSameKind(j: J, other: J): boolean {
@@ -252,7 +255,7 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                 }
 
                 // Handle the capture with the wrapper - use the element for pattern matching
-                const success = this.matcher.handleCapture(captureMarker, targetElement as J, targetWrapper as J.RightPadded<J> | undefined);
+                const success = await this.matcher.handleCapture(captureMarker, targetElement as J, targetWrapper as J.RightPadded<J> | undefined);
                 if (!success) {
                     const captureName = captureMarker.captureName || 'unnamed';
                     return this.captureConflict(captureName);
@@ -337,90 +340,6 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
         return this.match;
     }
 
-    override async visitMethodInvocation(methodInvocation: J.MethodInvocation, other: J): Promise<J | undefined> {
-        // Check if any arguments are variadic captures
-        const hasVariadicCapture = methodInvocation.arguments.elements.some(arg =>
-            PlaceholderUtils.isVariadicCapture(arg)
-        );
-
-        // If no variadic captures, use parent implementation (which includes semantic/type-aware matching)
-        if (!hasVariadicCapture) {
-            return super.visitMethodInvocation(methodInvocation, other);
-        }
-
-        // Otherwise, handle variadic captures ourselves
-        if (!this.match) {
-            return this.abort(methodInvocation);
-        }
-
-        if (other.kind !== J.Kind.MethodInvocation) {
-            // Set up cursors for kindMismatch
-            const savedCursor = this.cursor;
-            const savedTargetCursor = this.targetCursor;
-            this.cursor = new Cursor(methodInvocation, this.cursor);
-            this.targetCursor = new Cursor(other, this.targetCursor);
-            try {
-                return this.kindMismatch();
-            } finally {
-                this.cursor = savedCursor;
-                this.targetCursor = savedTargetCursor;
-            }
-        }
-
-        const otherMethodInvocation = other as J.MethodInvocation;
-
-        // Set up cursors for the entire method
-        const savedCursor = this.cursor;
-        const savedTargetCursor = this.targetCursor;
-        this.cursor = new Cursor(methodInvocation, this.cursor);
-        this.targetCursor = new Cursor(otherMethodInvocation, this.targetCursor);
-        try {
-            // Compare select
-            if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
-                return this.structuralMismatch('select');
-            }
-
-            // Visit select if present
-            if (methodInvocation.select && otherMethodInvocation.select) {
-                await this.visit(methodInvocation.select.element, otherMethodInvocation.select.element);
-                if (!this.match) return methodInvocation;
-            }
-
-            // A pattern that spells out no type arguments says nothing about them, as with parentheses
-            if (methodInvocation.typeParameters) {
-                if (!otherMethodInvocation.typeParameters) {
-                    return this.structuralMismatch('typeParameters');
-                }
-
-                if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
-                    return this.arrayLengthMismatch('typeParameters.elements');
-                }
-
-                // Visit each type parameter in lock step (visit RightPadded to check for markers)
-                for (let i = 0; i < methodInvocation.typeParameters.elements.length; i++) {
-                    await this.visitRightPadded(methodInvocation.typeParameters.elements[i], otherMethodInvocation.typeParameters.elements[i] as any);
-                    if (!this.match) return methodInvocation;
-                }
-            }
-
-            // Visit name
-            await this.visit(methodInvocation.name, otherMethodInvocation.name);
-            if (!this.match) {
-                return methodInvocation;
-            }
-
-            // Special handling for variadic captures in arguments
-            if (!await this.matchArguments(methodInvocation.arguments.elements, otherMethodInvocation.arguments.elements)) {
-                return this.structuralMismatch('arguments');
-            }
-
-            return methodInvocation;
-        } finally {
-            this.cursor = savedCursor;
-            this.targetCursor = savedTargetCursor;
-        }
-    }
-
     override async visitBlock(block: J.Block, other: J): Promise<J | undefined> {
         // Check if any statements have CaptureMarker indicating they're variadic
         const hasVariadicCapture = block.statements.some(stmt => {
@@ -522,14 +441,6 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
         }
     }
 
-    /**
-     * Matches argument lists, with special handling for variadic captures.
-     * A variadic capture can match zero or more consecutive arguments.
-     */
-    private async matchArguments(patternArgs: J.RightPadded<J>[], targetArgs: J.RightPadded<J>[]): Promise<boolean> {
-        return await this.matchSequence(patternArgs, targetArgs, true);
-    }
-
     /**
      * Generic sequence matching with variadic capture support.
      * Works for any sequence of JRightPadded elements (arguments, statements, etc.).
@@ -693,7 +604,7 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                 const savedState = this.matcher.saveState();
 
                 // Handle the variadic capture
-                const success = this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
+                const success = await this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
                 if (!success) {
                     // Restore state and try next amount
                     this.matcher.restoreState(savedState);
@@ -958,7 +869,7 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
                     this.debug.log('debug', 'constraint', `Constraint passed for capture: ${captureMarker.captureName}`);
                 }
 
-                const success = this.matcher.handleCapture(captureMarker, target, undefined);
+                const success = await this.matcher.handleCapture(captureMarker, target, undefined);
                 if (!success) {
                     return this.abort(j) as R;
                 }
@@ -1055,7 +966,7 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
                     this.debug.log('debug', 'constraint', `Constraint passed for wrapped capture: ${captureMarker.captureName}`);
                 }
 
-                const success = this.matcher.handleCapture(captureMarker, targetElement as J, targetWrapper as J.RightPadded<J> | undefined);
+                const success = await this.matcher.handleCapture(captureMarker, targetElement as J, targetWrapper as J.RightPadded<J> | undefined);
                 if (!success) {
                     return this.abort(right);
                 }
@@ -1407,7 +1318,7 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
 
                 const savedState = this.matcher.saveState();
 
-                const success = this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
+                const success = await this.matcher.handleVariadicCapture(captureMarker, capturedElements, capturedWrappers);
                 if (!success) {
                     this.matcher.restoreState(savedState);
                     continue;
@@ -1462,25 +1373,3 @@ export class DebugPatternMatchingComparator extends PatternMatchingComparator {
         }
     }
 }
-
-/** Whether anything under `node`, the padding wrappers a marker moves onto included, is a capture. */
-function containsCapture(node: unknown): boolean {
-    if (node === null || typeof node !== 'object') {
-        return false;
-    }
-    if (Array.isArray(node)) {
-        return node.some(containsCapture);
-    }
-    const record = node as Record<string, unknown>;
-    if (typeof record.kind !== 'string') {
-        return false;
-    }
-    // Attribution is a cyclic graph, and a capture is never reachable through one
-    if (Type.isType(node)) {
-        return false;
-    }
-    if (record.markers && PlaceholderUtils.getCaptureMarker(node as { markers: Markers })) {
-        return true;
-    }
-    return Object.entries(record).some(([key, value]) => key !== 'markers' && containsCapture(value));
-}