@openrewrite/rewrite 8.66.1 → 8.66.3

package/src/javascript/templating/placeholder-replacement.ts

@@ -20,7 +20,7 @@ import {JavaScriptVisitor} from '../visitor';
 import {produce} from 'immer';
 import {PlaceholderUtils} from './utils';
 import {CaptureImpl, TemplateParamImpl, CaptureValue, CAPTURE_NAME_SYMBOL} from './capture';
-import {Parameter} from './engine';
+import {Parameter} from './types';
 
 /**
  * Visitor that replaces placeholder nodes with actual parameter values.
@@ -34,6 +34,123 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
         super();
     }
 
+    async visit<R extends J>(tree: J, p: any, parent?: Cursor): Promise<R | undefined> {
+        // Check if this node is a placeholder
+        // BUT: Don't handle `JS.BindingElement` here - let `visitBindingElement` preserve `propertyName`
+        if (tree.kind !== JS.Kind.BindingElement && this.isPlaceholder(tree)) {
+            const replacement = this.replacePlaceholder(tree);
+            if (replacement !== tree) {
+                return replacement as R;
+            }
+        }
+
+        // Continue with normal traversal
+        return super.visit(tree, p, parent);
+    }
+
+    /**
+     * Override visitBindingElement to preserve propertyName from template when replacing.
+     * For example, in `{ ref: ${ref} }`, we want to preserve `ref:` when replacing ${ref}.
+     */
+    override async visitBindingElement(bindingElement: JS.BindingElement, p: any): Promise<J | undefined> {
+        // Visit the name to potentially replace placeholders
+        const visitedName = await this.visit(bindingElement.name, p);
+
+        // If the name changed (placeholder was replaced), preserve the BindingElement structure
+        // including the propertyName from the template
+        if (visitedName !== bindingElement.name) {
+            return produce(bindingElement, draft => {
+                draft.name = visitedName as any;
+                // propertyName is already set from the template and will be preserved by produce
+            });
+        }
+
+        return bindingElement;
+    }
+
+    /**
+     * Override visitContainer to handle variadic expansion for containers.
+     * This handles J.Container instances anywhere in the AST (method arguments, etc.).
+     */
+    override async visitContainer<T extends J>(container: J.Container<T>, p: any): Promise<J.Container<T>> {
+        // Check if any elements are placeholders (possibly variadic)
+        const hasPlaceholder = container.elements.some(elem => this.isPlaceholder(elem.element));
+
+        if (!hasPlaceholder) {
+            return super.visitContainer(container, p);
+        }
+
+        // Expand variadic placeholders in the container's elements
+        const newElements = await this.expandVariadicElements(container.elements, undefined, p);
+
+        return produce(container, draft => {
+            draft.elements = newElements as any;
+        });
+    }
+
+    /**
+     * Override visitRightPadded to handle single placeholder replacements.
+     * The base implementation will visit the element, which triggers our visit() override
+     * for placeholder detection and replacement.
+     */
+    override async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: any): Promise<J.RightPadded<T> | undefined> {
+        return super.visitRightPadded(right, p);
+    }
+
+    /**
+     * Override visitBlock to handle variadic expansion in block statements.
+     * Block.statements is J.RightPadded<Statement>[] (not a Container), so we need
+     * array-level access for variadic expansion.
+     */
+    override async visitBlock(block: J.Block, p: any): Promise<J | undefined> {
+        const hasPlaceholder = block.statements.some(stmt => {
+            const stmtElement = stmt.element;
+            // Check if it's an ExpressionStatement containing a placeholder
+            if (stmtElement.kind === JS.Kind.ExpressionStatement) {
+                const exprStmt = stmtElement as JS.ExpressionStatement;
+                return this.isPlaceholder(exprStmt.expression);
+            }
+            return this.isPlaceholder(stmtElement);
+        });
+
+        if (!hasPlaceholder) {
+            return super.visitBlock(block, p);
+        }
+
+        // Unwrap function to extract placeholder from ExpressionStatement
+        const unwrapStatement = (element: J): J => {
+            if (element.kind === JS.Kind.ExpressionStatement) {
+                return (element as JS.ExpressionStatement).expression;
+            }
+            return element;
+        };
+
+        const newStatements = await this.expandVariadicElements(block.statements, unwrapStatement, p);
+
+        return produce(block, draft => {
+            draft.statements = newStatements;
+        });
+    }
+
+    /**
+     * Override visitJsCompilationUnit to handle variadic expansion in top-level statements.
+     * CompilationUnit.statements is J.RightPadded<Statement>[] (not a Container), so we need
+     * array-level access for variadic expansion.
+     */
+    override async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, p: any): Promise<J | undefined> {
+        const hasPlaceholder = compilationUnit.statements.some(stmt => this.isPlaceholder(stmt.element));
+
+        if (!hasPlaceholder) {
+            return super.visitJsCompilationUnit(compilationUnit, p);
+        }
+
+        const newStatements = await this.expandVariadicElements(compilationUnit.statements, undefined, p);
+
+        return produce(compilationUnit, draft => {
+            draft.statements = newStatements;
+        });
+    }
+
     /**
      * Merges prefixes by preserving comments from the source element
      * while using whitespace from the template placeholder.
@@ -83,8 +200,15 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                     if (param) {
                         let arrayToExpand: J[] | J.RightPadded<J>[] | undefined = undefined;
 
+                        // Check if it's a J.Container
+                        const isContainer = param.value && typeof param.value === 'object' &&
+                            param.value.kind === J.Kind.Container;
+                        if (isContainer) {
+                            // Extract elements from J.Container
+                            arrayToExpand = param.value.elements as J.RightPadded<J>[];
+                        }
                         // Check if it's a direct Tree[] array
-                        if (Array.isArray(param.value)) {
+                        else if (Array.isArray(param.value)) {
                             arrayToExpand = param.value as J[];
                         }
                         // Check if it's a CaptureValue
@@ -97,7 +221,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                         // Check if it's a direct variadic capture
                         else {
                             const isCapture = param.value instanceof CaptureImpl ||
-                                             (param.value && typeof param.value === 'object' && param.value[CAPTURE_NAME_SYMBOL]);
+                                (param.value && typeof param.value === 'object' && param.value[CAPTURE_NAME_SYMBOL]);
                             if (isCapture) {
                                 const name = param.value[CAPTURE_NAME_SYMBOL] || param.value.name;
                                 const capture = Array.from(this.substitutions.values())
@@ -167,7 +291,28 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             // Not a placeholder (or expansion failed) - process normally
             const replacedElement = await this.visit(element, p);
             if (replacedElement) {
-                newElements.push(produce(wrapped, draft => {
+                // Check if the replacement came from a capture with a wrapper (to preserve markers)
+                const placeholderNode = unwrapElement(element);
+                const placeholderText = this.getPlaceholderText(placeholderNode);
+                let wrapperToUse = wrapped;
+
+                if (placeholderText && this.isPlaceholder(placeholderNode)) {
+                    const param = this.substitutions.get(placeholderText);
+                    if (param) {
+                        const isCapture = param.value instanceof CaptureImpl ||
+                            (param.value && typeof param.value === 'object' && param.value[CAPTURE_NAME_SYMBOL]);
+                        if (isCapture) {
+                            const name = param.value[CAPTURE_NAME_SYMBOL] || param.value.name;
+                            const wrapper = this.wrappersMap.get(name);
+                            // Use captured wrapper if available and not an array (non-variadic)
+                            if (wrapper && !Array.isArray(wrapper)) {
+                                wrapperToUse = wrapper as J.RightPadded<J>;
+                            }
+                        }
+                    }
+                }
+
+                newElements.push(produce(wrapperToUse, draft => {
                     draft.element = replacedElement;
                 }));
             }
@@ -176,80 +321,6 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
         return newElements;
     }
 
-    async visit<R extends J>(tree: J, p: any, parent?: Cursor): Promise<R | undefined> {
-        // Check if this node is a placeholder
-        if (this.isPlaceholder(tree)) {
-            const replacement = this.replacePlaceholder(tree);
-            if (replacement !== tree) {
-                return replacement as R;
-            }
-        }
-
-        // Continue with normal traversal
-        return super.visit(tree, p, parent);
-    }
-
-    override async visitMethodInvocation(method: J.MethodInvocation, p: any): Promise<J | undefined> {
-        // Check if any arguments are placeholders (possibly variadic)
-        const hasPlaceholder = method.arguments.elements.some(arg => this.isPlaceholder(arg.element));
-
-        if (!hasPlaceholder) {
-            return super.visitMethodInvocation(method, p);
-        }
-
-        const newArguments = await this.expandVariadicElements(method.arguments.elements, undefined, p);
-
-        return produce(method, draft => {
-            draft.arguments.elements = newArguments;
-        });
-    }
-
-    override async visitBlock(block: J.Block, p: any): Promise<J | undefined> {
-        // Check if any statements are placeholders (possibly variadic)
-        const hasPlaceholder = block.statements.some(stmt => {
-            const stmtElement = stmt.element;
-            // Check if it's an ExpressionStatement containing a placeholder
-            if (stmtElement.kind === JS.Kind.ExpressionStatement) {
-                const exprStmt = stmtElement as JS.ExpressionStatement;
-                return this.isPlaceholder(exprStmt.expression);
-            }
-            return this.isPlaceholder(stmtElement);
-        });
-
-        if (!hasPlaceholder) {
-            return super.visitBlock(block, p);
-        }
-
-        // Unwrap function to extract placeholder from ExpressionStatement
-        const unwrapStatement = (element: J): J => {
-            if (element.kind === JS.Kind.ExpressionStatement) {
-                return (element as JS.ExpressionStatement).expression;
-            }
-            return element;
-        };
-
-        const newStatements = await this.expandVariadicElements(block.statements, unwrapStatement, p);
-
-        return produce(block, draft => {
-            draft.statements = newStatements;
-        });
-    }
-
-    override async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, p: any): Promise<J | undefined> {
-        // Check if any statements are placeholders (possibly variadic)
-        const hasPlaceholder = compilationUnit.statements.some(stmt => this.isPlaceholder(stmt.element));
-
-        if (!hasPlaceholder) {
-            return super.visitJsCompilationUnit(compilationUnit, p);
-        }
-
-        const newStatements = await this.expandVariadicElements(compilationUnit.statements, undefined, p);
-
-        return produce(compilationUnit, draft => {
-            draft.statements = newStatements;
-        });
-    }
-
     /**
      * Checks if a node is a placeholder.
      *
@@ -263,6 +334,10 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
         } else if (node.kind === J.Kind.Literal) {
             const literal = node as J.Literal;
             return literal.valueSource?.startsWith(PlaceholderUtils.PLACEHOLDER_PREFIX) || false;
+        } else if (node.kind === JS.Kind.BindingElement) {
+            // Check if the BindingElement's name is a placeholder
+            const bindingElement = node as JS.BindingElement;
+            return this.isPlaceholder(bindingElement.name);
         }
         return false;
     }
@@ -323,13 +398,13 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
 
         // Check if the parameter value is a Capture (could be a Proxy) or TemplateParam
         const isCapture = param.value instanceof CaptureImpl ||
-                         (param.value && typeof param.value === 'object' && param.value[CAPTURE_NAME_SYMBOL]);
+            (param.value && typeof param.value === 'object' && param.value[CAPTURE_NAME_SYMBOL]);
         const isTemplateParam = param.value instanceof TemplateParamImpl;
 
         if (isCapture || isTemplateParam) {
             // Simple capture/template param (no property path for template params)
             const name = isTemplateParam ? param.value.name :
-                        (param.value[CAPTURE_NAME_SYMBOL] || param.value.name);
+                (param.value[CAPTURE_NAME_SYMBOL] || param.value.name);
             const matchedNode = this.values.get(name);
             if (matchedNode && !Array.isArray(matchedNode)) {
                 return produce(matchedNode, draft => {
@@ -342,6 +417,30 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             return placeholder;
         }
 
+        // Check if the parameter value is a J.RightPadded wrapper
+        const isRightPadded = param.value && typeof param.value === 'object' &&
+            param.value.kind === J.Kind.RightPadded && isTree(param.value.element);
+
+        if (isRightPadded) {
+            // Extract the element from the J.RightPadded wrapper
+            const element = param.value.element as J;
+            return produce(element, draft => {
+                draft.markers = placeholder.markers;
+                draft.prefix = this.mergePrefix(element.prefix, placeholder.prefix);
+            });
+        }
+
+        // Check if the parameter value is a J.Container
+        const isContainer = param.value && typeof param.value === 'object' &&
+            param.value.kind === J.Kind.Container;
+
+        if (isContainer) {
+            // J.Container should be handled by expandVariadicElements
+            // For now, return placeholder - the expansion will happen at a higher level
+            // This should not happen in normal usage, as containers are typically used in argument positions
+            return placeholder;
+        }
+
         // If the parameter value is an AST node, use it directly
         if (isTree(param.value)) {
             // Return the AST node, preserving comments from the source
@@ -365,6 +464,10 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             return (node as J.Identifier).simpleName;
         } else if (node.kind === J.Kind.Literal) {
             return (node as J.Literal).valueSource || null;
+        } else if (node.kind === JS.Kind.BindingElement) {
+            // Extract placeholder text from the BindingElement's name
+            const bindingElement = node as JS.BindingElement;
+            return this.getPlaceholderText(bindingElement.name);
         }
         return null;
     }

package/src/javascript/templating/rewrite.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Cursor} from '../..';
+import {Cursor, ExecutionContext, Recipe} from '../..';
 import {J} from '../../java';
 import {RewriteRule, RewriteConfig} from './types';
-import {Pattern} from './pattern';
+import {Pattern, MatchResult} from './pattern';
 import {Template} from './template';
 
 /**
@@ -25,24 +25,92 @@ import {Template} from './template';
 class RewriteRuleImpl implements RewriteRule {
     constructor(
         private readonly before: Pattern[],
-        private readonly after: Template
+        private readonly after: Template | ((match: MatchResult) => Template),
+        private readonly where?: (node: J, cursor: Cursor) => boolean | Promise<boolean>,
+        private readonly whereNot?: (node: J, cursor: Cursor) => boolean | Promise<boolean>
     ) {
     }
 
     async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
         for (const pattern of this.before) {
-            const match = await pattern.match(node);
+            // Pass cursor to pattern.match() for context-aware capture constraints
+            const match = await pattern.match(node, cursor);
             if (match) {
-                const result = await this.after.apply(cursor, node, match);
+                // Evaluate context predicates after structural match
+                if (this.where) {
+                    const whereResult = await this.where(node, cursor);
+                    if (!whereResult) {
+                        continue; // Pattern matched but context doesn't, try next pattern
+                    }
+                }
+
+                if (this.whereNot) {
+                    const whereNotResult = await this.whereNot(node, cursor);
+                    if (whereNotResult) {
+                        continue; // Pattern matched but context is excluded, try next pattern
+                    }
+                }
+
+                // Apply transformation
+                let result: J | undefined;
+
+                if (typeof this.after === 'function') {
+                    // Call the function to get a template, then apply it
+                    const template = this.after(match);
+                    result = await template.apply(cursor, node, match);
+                } else {
+                    // Use template.apply() as before
+                    result = await this.after.apply(cursor, node, match);
+                }
+
                 if (result) {
                     return result;
                 }
             }
         }
 
-        // Return undefined if no patterns match
+        // Return undefined if no patterns match or all context checks failed
         return undefined;
     }
+
+    andThen(next: RewriteRule): RewriteRule {
+        const first = this;
+        return new (class extends RewriteRuleImpl {
+            constructor() {
+                // Pass empty patterns and a function that will never be called
+                // since we override tryOn
+                super([], () => undefined as unknown as Template);
+            }
+
+            async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
+                const firstResult = await first.tryOn(cursor, node);
+                if (firstResult !== undefined) {
+                    const secondResult = await next.tryOn(cursor, firstResult);
+                    return secondResult ?? firstResult;
+                }
+                return undefined;
+            }
+        })();
+    }
+
+    orElse(alternative: RewriteRule): RewriteRule {
+        const first = this;
+        return new (class extends RewriteRuleImpl {
+            constructor() {
+                // Pass empty patterns and a function that will never be called
+                // since we override tryOn
+                super([], () => undefined as unknown as Template);
+            }
+
+            async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
+                const firstResult = await first.tryOn(cursor, node);
+                if (firstResult !== undefined) {
+                    return firstResult;
+                }
+                return await alternative.tryOn(cursor, node);
+            }
+        })();
+    }
 }
 
 /**
@@ -53,20 +121,26 @@ class RewriteRuleImpl implements RewriteRule {
  *
  * @example
  * // Single pattern
- * const swapOperands = rewrite(() => ({
- *     before: pattern`${"left"} + ${"right"}`,
- *     after: template`${"right"} + ${"left"}`
- * }));
+ * const swapOperands = rewrite(() => {
+ *     const { left, right } = { left: capture(), right: capture() };
+ *     return {
+ *         before: pattern`${left} + ${right}`,
+ *         after: template`${right} + ${left}`
+ *     };
+ * });
  *
  * @example
  * // Multiple patterns
- * const normalizeComparisons = rewrite(() => ({
- *     before: [
- *         pattern`${"left"} == ${"right"}`,
- *         pattern`${"left"} === ${"right"}`
- *     ],
- *     after: template`${"left"} === ${"right"}`
- * }));
+ * const normalizeComparisons = rewrite(() => {
+ *     const { left, right } = { left: capture(), right: capture() };
+ *     return {
+ *         before: [
+ *             pattern`${left} == ${right}`,
+ *             pattern`${left} === ${right}`
+ *         ],
+ *         after: template`${left} === ${right}`
+ *     };
+ * });
  *
  * @example
  * // Using in a visitor - IMPORTANT: use `|| node` to handle undefined when no match
@@ -91,5 +165,65 @@ export function rewrite(
         throw new Error('Builder function must return an object with before and after properties');
     }
 
-    return new RewriteRuleImpl(Array.isArray(config.before) ? config.before : [config.before], config.after);
+    return new RewriteRuleImpl(
+        Array.isArray(config.before) ? config.before : [config.before],
+        config.after,
+        config.where,
+        config.whereNot
+    );
+}
+
+/**
+ * Creates a RewriteRule from a Recipe by using its editor visitor.
+ *
+ * This allows recipes to be used in the same chaining pattern as other rewrite rules,
+ * enabling composition with `andThen()`.
+ *
+ * @param recipe The recipe whose editor will be used to transform nodes
+ * @param ctx The execution context to pass to the recipe's editor
+ * @returns A RewriteRule that applies the recipe's editor to nodes
+ *
+ * @example
+ * ```typescript
+ * class MyRecipe extends Recipe {
+ *     name = "my.recipe";
+ *     displayName = "My Recipe";
+ *     description = "Transforms code.";
+ *
+ *     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+ *         return new MyVisitor();
+ *     }
+ * }
+ *
+ * // In a visitor:
+ * override async visitBinary(binary: J.Binary, p: ExecutionContext): Promise<J | undefined> {
+ *     const rule1 = rewrite(() => ({
+ *         before: pattern`${capture('a')} + ${capture('b')}`,
+ *         after: template`${capture('b')} + ${capture('a')}`
+ *     }));
+ *
+ *     const rule2 = fromRecipe(new MyRecipe(), p);
+ *
+ *     // Chain the pattern-based rule with the recipe
+ *     const combined = rule1.andThen(rule2);
+ *     return await combined.tryOn(this.cursor, binary) || binary;
+ * }
+ * ```
+ */
+export const fromRecipe = (recipe: Recipe, ctx: ExecutionContext): RewriteRule => {
+    return new (class extends RewriteRuleImpl {
+        constructor() {
+            // Pass empty patterns and a function that will never be called
+            // since we override tryOn
+            super([], () => undefined as unknown as Template);
+        }
+
+        async tryOn(cursor: Cursor, tree: J): Promise<J | undefined> {
+            const visitor = await recipe.editor();
+            const result = await visitor.visit<J>(tree, ctx, cursor);
+
+            // Return undefined if the visitor didn't change the node
+            return result !== tree ? result : undefined;
+        }
+    })();
 }