@openrewrite/rewrite 8.67.0-20251105-091131 → 8.67.0-20251105-105242

package/src/javascript/templating/comparator.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Cursor, Tree} from '../..';
+import {Cursor, isTree, Tree} from '../..';
 import {J} from '../../java';
 import {JS} from '../index';
 import {JavaScriptSemanticComparatorVisitor} from '../comparator';
@@ -38,26 +38,11 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
         super(lenientTypeMatching);
     }
 
-    /**
-     * Extracts the wrapper from the cursor if the parent is a RightPadded.
-     */
-    private getWrapperFromCursor(cursor: Cursor): J.RightPadded<J> | undefined {
-        if (!cursor.parent) {
-            return undefined;
-        }
-        const parent = cursor.parent.value;
-        // Check if parent is a RightPadded by checking its kind
-        if ((parent as any).kind === J.Kind.RightPadded) {
-            return parent as J.RightPadded<J>;
-        }
-        return undefined;
-    }
-
     override async visit<R extends J>(j: Tree, p: J, parent?: Cursor): Promise<R | undefined> {
-        // Check if the pattern node is a capture - this handles captures anywhere in the tree
+        // Check if the pattern node is a capture - this handles unwrapped captures
+        // (Wrapped captures in J.RightPadded are handled by visitRightPadded override)
         if (PlaceholderUtils.isCapture(j as J)) {
-            const wrapper = this.getWrapperFromCursor(this.cursor);
-            const success = this.matcher.handleCapture(j as J, p, wrapper);
+            const success = this.matcher.handleCapture(j as J, p, undefined);
             if (!success) {
                 return this.abort(j) as R;
             }
@@ -68,27 +53,58 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
             return j as R;
         }
 
-        return super.visit(j, p, parent);
+        return await super.visit(j, p, parent);
     }
 
     protected hasSameKind(j: J, other: J): boolean {
         return super.hasSameKind(j, other) ||
-               (j.kind == J.Kind.Identifier && PlaceholderUtils.isCapture(j as J.Identifier));
+            (j.kind == J.Kind.Identifier && PlaceholderUtils.isCapture(j as J.Identifier));
     }
 
-    override async visitIdentifier(identifier: J.Identifier, other: J): Promise<J | undefined> {
-        if (PlaceholderUtils.isCapture(identifier)) {
-            const wrapper = this.getWrapperFromCursor(this.cursor);
-            const success = this.matcher.handleCapture(identifier, other, wrapper);
-            return success ? identifier : this.abort(identifier);
+    /**
+     * Override visitRightPadded to check if this wrapper has a CaptureMarker.
+     * If so, capture the entire wrapper (to preserve markers like semicolons).
+     */
+    override async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: J): Promise<J.RightPadded<T>> {
+        if (!this.match) {
+            return right;
+        }
+
+        // Check if this RightPadded or its element has a CaptureMarker (attached during pattern construction)
+        const element = right.element;
+        let captureMarker = undefined;
+
+        // Check RightPadded itself
+        if (right.markers) {
+            captureMarker = PlaceholderUtils.getCaptureMarker(right);
+        }
+
+        // Check element if it's a J node
+        if (!captureMarker && isTree(element)) {
+            captureMarker = PlaceholderUtils.getCaptureMarker(element);
+        }
+        if (captureMarker) {
+            // Extract the target wrapper if it's also a RightPadded
+            const isRightPadded = (p as any).kind === J.Kind.RightPadded;
+            const targetWrapper = isRightPadded ? (p as unknown) as J.RightPadded<T> : undefined;
+            const targetElement = isRightPadded ? targetWrapper!.element : p;
+
+            // Handle the capture with the wrapper - use the element for pattern matching
+            const success = this.matcher.handleCapture(element as J, targetElement as J, targetWrapper as J.RightPadded<J> | undefined);
+            if (!success) {
+                return this.abort(right);
+            }
+            return right;
         }
-        return super.visitIdentifier(identifier, other);
+
+        // Not a capture wrapper - use parent implementation
+        return super.visitRightPadded(right, p);
     }
 
     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.element)
+            PlaceholderUtils.isVariadicCapture(arg)
         );
 
         // If no variadic captures, use parent implementation (which includes semantic/type-aware matching)
@@ -172,10 +188,9 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
     }
 
     override async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, other: J): Promise<J | undefined> {
-        // Check if any statements are variadic captures (unwrap ExpressionStatement wrappers first)
+        // Check if any statements are variadic captures
         const hasVariadicCapture = compilationUnit.statements.some(stmt => {
-            const unwrapped = PlaceholderUtils.unwrapStatementCapture(stmt.element);
-            return PlaceholderUtils.isVariadicCapture(unwrapped);
+            return PlaceholderUtils.isVariadicCapture(stmt);
         });
 
         // If no variadic captures, use parent implementation
@@ -394,14 +409,8 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
             const savedMatch = this.match;
             const savedState = this.matcher.saveState();
 
-            // Push wrapper onto cursor so captures can access it
-            const savedCursor = this.cursor;
-            this.cursor = new Cursor(targetWrapper, this.cursor);
-            try {
-                await this.visit(patternElement, targetElement);
-            } finally {
-                this.cursor = savedCursor;
-            }
+            await this.visit(patternElement, targetElement);
+
             if (!this.match) {
                 // Restore state on match failure
                 this.match = savedMatch;

package/src/javascript/templating/pattern.ts

@@ -164,10 +164,10 @@ export class Pattern {
      * @returns This pattern for method chaining
      *
      * @example
-     * pattern`isDate(${capture('date')})`
+     * pattern`forwardRef((${props}, ${ref}) => ${body})`
      *     .configure({
-     *         imports: ['import { isDate } from \"util\"'],
-     *         dependencies: { 'util': '^1.0.0' }
+     *         context: ['import { forwardRef } from "react"'],
+     *         dependencies: {'@types/react': '^18.0.0'}
      *     })
      */
     configure(options: PatternOptions): Pattern {
@@ -387,7 +387,7 @@ class Matcher {
         // Default to true for backward compatibility with existing patterns
         const lenientTypeMatching = this.pattern.options.lenientTypeMatching ?? true;
         const comparator = new PatternMatchingComparator({
-            handleCapture: (p, t) => this.handleCapture(p, t),
+            handleCapture: (p, t, w) => this.handleCapture(p, t, w),
             handleVariadicCapture: (p, ts, ws) => this.handleVariadicCapture(p, ts, ws),
             saveState: () => this.saveState(),
             restoreState: (state) => this.restoreState(state)
@@ -709,9 +709,33 @@ class TemplateProcessor {
         // Mark as visited to avoid cycles
         visited.add(node);
 
+        // Check if this is a RightPadded containing a capture identifier
+        // Attach marker to the wrapper to preserve markers (like semicolons) during capture
+        if (node.kind === J.Kind.RightPadded &&
+            node.element?.kind === J.Kind.Identifier &&
+            node.element.simpleName?.startsWith(PlaceholderUtils.CAPTURE_PREFIX)) {
+
+            const captureInfo = PlaceholderUtils.parseCapture(node.element.simpleName);
+            if (captureInfo) {
+                // Initialize markers on the RightPadded
+                if (!node.markers) {
+                    node.markers = { kind: 'org.openrewrite.marker.Markers', id: randomId(), markers: [] };
+                }
+                if (!node.markers.markers) {
+                    node.markers.markers = [];
+                }
+
+                // Find the original capture object to get variadic options
+                const captureObj = this.captures.find(c => c.getName() === captureInfo.name);
+                const variadicOptions = captureObj?.getVariadicOptions();
+
+                // Add CaptureMarker to the RightPadded
+                node.markers.markers.push(new CaptureMarker(captureInfo.name, variadicOptions));
+            }
+        }
         // Check if this is an ExpressionStatement containing a capture identifier
         // For statement-level captures, we attach the marker to the ExpressionStatement itself
-        if (node.kind === JS.Kind.ExpressionStatement &&
+        else if (node.kind === JS.Kind.ExpressionStatement &&
             node.expression?.kind === J.Kind.Identifier &&
             node.expression.simpleName?.startsWith(PlaceholderUtils.CAPTURE_PREFIX)) {
 
@@ -733,7 +757,7 @@ class TemplateProcessor {
                 node.markers.markers.push(new CaptureMarker(captureInfo.name, variadicOptions));
             }
         }
-        // For non-statement captures (expressions), attach marker to the identifier
+        // For non-statement, non-wrapped captures (expressions), attach marker to the identifier
         else if (node.kind === J.Kind.Identifier && node.simpleName?.startsWith(PlaceholderUtils.CAPTURE_PREFIX)) {
             const captureInfo = PlaceholderUtils.parseCapture(node.simpleName);
             if (captureInfo) {

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

@@ -167,7 +167,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;
                 }));
             }

package/src/javascript/templating/rewrite.ts

@@ -25,7 +25,7 @@ import {Template} from './template';
 class RewriteRuleImpl implements RewriteRule {
     constructor(
         private readonly before: Pattern[],
-        private readonly after: Template | ((match: MatchResult) => Promise<J>)
+        private readonly after: Template | ((match: MatchResult) => Template)
     ) {
     }
 
@@ -36,8 +36,9 @@ class RewriteRuleImpl implements RewriteRule {
                 let result: J | undefined;
 
                 if (typeof this.after === 'function') {
-                    // Call the function directly with the match result
-                    result = await this.after(match);
+                    // 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);
@@ -59,7 +60,7 @@ class RewriteRuleImpl implements RewriteRule {
             constructor() {
                 // Pass empty patterns and a function that will never be called
                 // since we override tryOn
-                super([], async () => undefined as unknown as J);
+                super([], () => undefined as unknown as Template);
             }
 
             async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
@@ -72,6 +73,25 @@ class RewriteRuleImpl implements RewriteRule {
             }
         })();
     }
+
+    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);
+            }
+        })();
+    }
 }
 
 /**
@@ -165,7 +185,7 @@ export const fromRecipe = (recipe: Recipe, ctx: ExecutionContext): RewriteRule =
         constructor() {
             // Pass empty patterns and a function that will never be called
             // since we override tryOn
-            super([], async () => undefined as unknown as J);
+            super([], () => undefined as unknown as Template);
         }
 
         async tryOn(cursor: Cursor, tree: J): Promise<J | undefined> {

package/src/javascript/templating/template.ts

@@ -210,7 +210,7 @@ export class Template {
      * @example
      * template`isDate(${capture('date')})`
      *     .configure({
-     *         imports: ['import { isDate } from "util"'],
+     *         context: ['import { isDate } from "util"'],
      *         dependencies: { 'util': '^1.0.0' }
      *     })
      */

package/src/javascript/templating/types.ts

@@ -331,6 +331,36 @@ export interface RewriteRule {
      * ```
      */
     andThen(next: RewriteRule): RewriteRule;
+
+    /**
+     * Creates a composite rule that tries this rule first, and if it doesn't match, tries an alternative rule.
+     *
+     * The resulting rule:
+     * 1. First applies this rule to the input node
+     * 2. If this rule matches and transforms the node, returns the result
+     * 3. If this rule returns undefined (no match), tries the alternative rule on the original node
+     *
+     * @param alternative The rule to try if this rule doesn't match
+     * @returns A new RewriteRule that tries both rules with fallback behavior
+     *
+     * @example
+     * ```typescript
+     * // Try specific pattern first, fall back to general pattern
+     * const specific = rewrite(() => ({
+     *     before: pattern`foo(${capture('x')}, 0)`,
+     *     after: template`bar(${capture('x')})`
+     * }));
+     *
+     * const general = rewrite(() => ({
+     *     before: pattern`foo(${capture('x')}, ${capture('y')})`,
+     *     after: template`baz(${capture('x')}, ${capture('y')})`
+     * }));
+     *
+     * const combined = specific.orElse(general);
+     * // Will try specific pattern first, if no match, try general pattern
+     * ```
+     */
+    orElse(alternative: RewriteRule): RewriteRule;
 }
 
 /**
@@ -338,5 +368,5 @@ export interface RewriteRule {
  */
 export interface RewriteConfig {
     before: Pattern | Pattern[],
-    after: Template | ((match: MatchResult) => Promise<J>)
+    after: Template | ((match: MatchResult) => Template)
 }

package/src/javascript/templating/utils.ts

@@ -17,7 +17,7 @@ import {J} from '../../java';
 import {JS} from '../index';
 import {JavaScriptParser} from '../parser';
 import {DependencyWorkspace} from '../dependency-workspace';
-import {Marker} from '../../markers';
+import {Marker, Markers} from '../../markers';
 import {randomId} from '../../uuid';
 import {VariadicOptions, Capture, Any} from './types';
 
@@ -177,7 +177,7 @@ export class PlaceholderUtils {
      * @param node The node to check
      * @returns The CaptureMarker or undefined
      */
-    static getCaptureMarker(node: J): CaptureMarker | undefined {
+    static getCaptureMarker(node: { markers: Markers }): CaptureMarker | undefined {
         for (const marker of node.markers.markers) {
             if (marker instanceof CaptureMarker) {
                 return marker;
@@ -235,7 +235,7 @@ export class PlaceholderUtils {
      * @param node The node to check
      * @returns true if the node has a variadic CaptureMarker, false otherwise
      */
-    static isVariadicCapture(node: J): boolean {
+    static isVariadicCapture(node: { markers: Markers }): boolean {
         for (const marker of node.markers.markers) {
             if (marker instanceof CaptureMarker && marker.variadicOptions) {
                 return true;
@@ -250,7 +250,7 @@ export class PlaceholderUtils {
      * @param node The node to extract variadic options from
      * @returns The VariadicOptions, or undefined if not a variadic capture
      */
-    static getVariadicOptions(node: J): VariadicOptions | undefined {
+    static getVariadicOptions(node: { markers: Markers }): VariadicOptions | undefined {
         for (const marker of node.markers.markers) {
             if (marker instanceof CaptureMarker) {
                 return marker.variadicOptions;
@@ -258,27 +258,4 @@ export class PlaceholderUtils {
         }
         return undefined;
     }
-
-    /**
-     * Checks if a statement is an ExpressionStatement wrapping a capture identifier.
-     * When a capture placeholder appears in statement position, the parser wraps it as
-     * an ExpressionStatement. This method unwraps it to get the identifier.
-     *
-     * @param stmt The statement to check
-     * @returns The unwrapped capture identifier, or the original statement if not wrapped
-     */
-    static unwrapStatementCapture(stmt: J): J {
-        // Check if it's an ExpressionStatement containing a capture identifier
-        if (stmt.kind === JS.Kind.ExpressionStatement) {
-            const exprStmt = stmt as JS.ExpressionStatement;
-            if (exprStmt.expression?.kind === J.Kind.Identifier) {
-                const identifier = exprStmt.expression as J.Identifier;
-                // Check if this is a capture placeholder
-                if (identifier.simpleName?.startsWith(this.CAPTURE_PREFIX)) {
-                    return identifier;
-                }
-            }
-        }
-        return stmt;
-    }
 }