@openrewrite/rewrite 8.67.0-20251105-160319 → 8.67.0-20251105-204403

package/src/javascript/comparator.ts

@@ -29,15 +29,27 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      */
     protected match: boolean = true;
 
+    /**
+     * Cursor tracking the current position in the target tree.
+     * Maintained in parallel with the pattern tree cursor (this.cursor).
+     */
+    protected targetCursor?: Cursor;
+
     /**
      * Compares two AST trees.
-     * 
-     * @param tree1 The first tree to compare
-     * @param tree2 The second tree to compare
+     *
+     * @param tree1 The first tree to compare (pattern tree)
+     * @param tree2 The second tree to compare (target tree)
+     * @param parentCursor1 Optional parent cursor for the pattern tree (for navigating to root)
+     * @param parentCursor2 Optional parent cursor for the target tree (for navigating to root)
      * @returns true if the trees match, false otherwise
      */
-    async compare(tree1: J, tree2: J): Promise<boolean> {
+    async compare(tree1: J, tree2: J, parentCursor1?: Cursor, parentCursor2?: Cursor): Promise<boolean> {
         this.match = true;
+        // Initialize targetCursor with parent if provided, otherwise undefined (will be set by visit())
+        this.targetCursor = parentCursor2;
+        // Initialize this.cursor (pattern cursor) with parent if provided
+        this.cursor = parentCursor1 || new Cursor(undefined, undefined);
         await this.visit(tree1, tree2);
         return this.match;
     }
@@ -180,14 +192,23 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
             return this.abort(j) as R;
         }
 
-        // Continue with normal visitation, passing the other node as context
-        return await super.visit(j, p);
+        // Update targetCursor to track the target node in parallel with the pattern cursor
+        // (Can be overridden by subclasses if they need cursor access before calling super)
+        const savedTargetCursor = this.targetCursor;
+        this.targetCursor = new Cursor(p, this.targetCursor);
+        try {
+            // Continue with normal visitation, passing the other node as context
+            return await super.visit(j, p);
+        } finally {
+            this.targetCursor = savedTargetCursor;
+        }
     }
 
     /**
      * Override visitRightPadded to compare only the elements, not markers or spacing.
      * The context parameter p contains the corresponding element from the other tree.
      * Pushes the wrapper onto the cursor stack so captures can access it.
+     * Also updates targetCursor in parallel.
      */
     public async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: J): Promise<J.RightPadded<T>> {
         if (!this.match) {
@@ -196,15 +217,19 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
 
         // Extract the other element if it's also a RightPadded
         const isRightPadded = (p as any).kind === J.Kind.RightPadded;
-        const otherElement = isRightPadded ? ((p as unknown) as J.RightPadded<T>).element : p;
+        const otherWrapper = isRightPadded ? (p as unknown) as J.RightPadded<T> : undefined;
+        const otherElement = isRightPadded ? otherWrapper!.element : p;
 
-        // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+        // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
         const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
         this.cursor = new Cursor(right, this.cursor);
+        this.targetCursor = otherWrapper ? new Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
         try {
             await this.visitProperty(right.element, otherElement);
         } finally {
             this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
         }
 
         return right;
@@ -214,6 +239,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * Override visitLeftPadded to compare only the elements, not markers or spacing.
      * The context parameter p contains the corresponding element from the other tree.
      * Pushes the wrapper onto the cursor stack so captures can access it.
+     * Also updates targetCursor in parallel.
      */
     public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>, p: J): Promise<J.LeftPadded<T>> {
         if (!this.match) {
@@ -222,15 +248,19 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
 
         // Extract the other element if it's also a LeftPadded
         const isLeftPadded = (p as any).kind === J.Kind.LeftPadded;
-        const otherElement = isLeftPadded ? ((p as unknown) as J.LeftPadded<T>).element : p;
+        const otherWrapper = isLeftPadded ? (p as unknown) as J.LeftPadded<T> : undefined;
+        const otherElement = isLeftPadded ? otherWrapper!.element : p;
 
-        // Push wrapper onto cursor, then compare only the elements, not markers or spacing
+        // Push wrappers onto both cursors, then compare only the elements, not markers or spacing
         const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
         this.cursor = new Cursor(left, this.cursor);
+        this.targetCursor = otherWrapper ? new Cursor(otherWrapper, this.targetCursor) : this.targetCursor;
         try {
             await this.visitProperty(left.element, otherElement);
         } finally {
             this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
         }
 
         return left;
@@ -240,6 +270,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
      * Override visitContainer to compare only the elements, not markers or spacing.
      * The context parameter p contains the corresponding element from the other tree.
      * Pushes the wrapper onto the cursor stack so captures can access it.
+     * Also updates targetCursor in parallel.
      */
     public async visitContainer<T extends J>(container: J.Container<T>, p: J): Promise<J.Container<T>> {
         if (!this.match) {
@@ -248,16 +279,19 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
 
         // Extract the other elements if it's also a Container
         const isContainer = (p as any).kind === J.Kind.Container;
-        const otherElements: J.RightPadded<T>[] = isContainer ? ((p as unknown) as J.Container<T>).elements : (p as any);
+        const otherContainer = isContainer ? (p as unknown) as J.Container<T> : undefined;
+        const otherElements: J.RightPadded<T>[] = isContainer ? otherContainer!.elements : (p as any);
 
         // Compare elements array length
         if (container.elements.length !== otherElements.length) {
             return this.abort(container);
         }
 
-        // Push wrapper onto cursor, then compare each element
+        // Push wrappers onto both cursors, then compare each element
         const savedCursor = this.cursor;
+        const savedTargetCursor = this.targetCursor;
         this.cursor = new Cursor(container, this.cursor);
+        this.targetCursor = otherContainer ? new Cursor(otherContainer, this.targetCursor) : this.targetCursor;
         try {
             for (let i = 0; i < container.elements.length; i++) {
                 await this.visitProperty(container.elements[i], otherElements[i]);
@@ -267,6 +301,7 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
             }
         } finally {
             this.cursor = savedCursor;
+            this.targetCursor = savedTargetCursor;
         }
 
         return container;

package/src/javascript/templating/capture.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {Cursor} from '../..';
 import {J, Type} from '../../java';
 import {Any, Capture, CaptureOptions, TemplateParam, VariadicOptions} from './types';
 
@@ -29,8 +30,8 @@ import {Any, Capture, CaptureOptions, TemplateParam, VariadicOptions} from './ty
  *     )
  * });
  */
-export function and<T>(...constraints: ((node: T) => boolean)[]): (node: T) => boolean {
-    return (node: T) => constraints.every(c => c(node));
+export function and<T>(...constraints: ((node: T, cursor?: Cursor) => boolean)[]): (node: T, cursor?: Cursor) => boolean {
+    return (node: T, cursor?: Cursor) => constraints.every(c => c(node, cursor));
 }
 
 /**
@@ -45,8 +46,8 @@ export function and<T>(...constraints: ((node: T) => boolean)[]): (node: T) => b
  *     )
  * });
  */
-export function or<T>(...constraints: ((node: T) => boolean)[]): (node: T) => boolean {
-    return (node: T) => constraints.some(c => c(node));
+export function or<T>(...constraints: ((node: T, cursor?: Cursor) => boolean)[]): (node: T, cursor?: Cursor) => boolean {
+    return (node: T, cursor?: Cursor) => constraints.some(c => c(node, cursor));
 }
 
 /**
@@ -58,8 +59,8 @@ export function or<T>(...constraints: ((node: T) => boolean)[]): (node: T) => bo
  *     constraint: not((node) => typeof node.value === 'string')
  * });
  */
-export function not<T>(constraint: (node: T) => boolean): (node: T) => boolean {
-    return (node: T) => !constraint(node);
+export function not<T>(constraint: (node: T, cursor?: Cursor) => boolean): (node: T, cursor?: Cursor) => boolean {
+    return (node: T, cursor?: Cursor) => !constraint(node, cursor);
 }
 
 // Symbol to access the internal capture name without triggering Proxy

package/src/javascript/templating/comparator.ts

@@ -41,18 +41,38 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
     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 unwrapped captures
         // (Wrapped captures in J.RightPadded are handled by visitRightPadded override)
-        if (PlaceholderUtils.isCapture(j as J)) {
-            const success = this.matcher.handleCapture(PlaceholderUtils.getCaptureMarker(j)!, p, undefined);
-            if (!success) {
-                return this.abort(j) as R;
+        // Note: targetCursor will be pushed by parent's visit() method after this check
+        const captureMarker = PlaceholderUtils.getCaptureMarker(j)!;
+        if (captureMarker) {
+
+            // Push targetCursor to position it at the captured node for constraint evaluation
+            // Only create cursor if targetCursor was initialized (meaning user provided one)
+            const savedTargetCursor = this.targetCursor;
+            const cursorAtCapturedNode = this.targetCursor !== undefined
+                ? new Cursor(p, this.targetCursor)
+                : undefined;
+            this.targetCursor = cursorAtCapturedNode;
+            try {
+                // Evaluate constraint with cursor at the captured node
+                if (captureMarker.constraint && !captureMarker.constraint(p, cursorAtCapturedNode)) {
+                    return this.abort(j) as R;
+                }
+
+                const success = this.matcher.handleCapture(captureMarker, p, undefined);
+                if (!success) {
+                    return this.abort(j) as R;
+                }
+                return j as R;
+            } finally {
+                this.targetCursor = savedTargetCursor;
             }
-            return j as R;
         }
 
         if (!this.match) {
             return j as R;
         }
 
+        // Continue with parent's visit which will push targetCursor and traverse
         return await super.visit(j, p, parent);
     }
 
@@ -79,12 +99,28 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
             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(captureMarker, targetElement as J, targetWrapper as J.RightPadded<J> | undefined);
-            if (!success) {
-                return this.abort(right);
+            // Push targetCursor to position it at the captured element for constraint evaluation
+            // Only create cursor if targetCursor was initialized (meaning user provided one)
+            const savedTargetCursor = this.targetCursor;
+            const cursorAtCapturedNode = this.targetCursor !== undefined
+                ? (targetWrapper ? new Cursor(targetWrapper, this.targetCursor) : new Cursor(targetElement, this.targetCursor))
+                : undefined;
+            this.targetCursor = cursorAtCapturedNode;
+            try {
+                // Evaluate constraint with cursor at the captured node
+                if (captureMarker.constraint && !captureMarker.constraint(targetElement as J, cursorAtCapturedNode)) {
+                    return this.abort(right);
+                }
+
+                // 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);
+                if (!success) {
+                    return this.abort(right);
+                }
+                return right;
+            } finally {
+                this.targetCursor = savedTargetCursor;
             }
-            return right;
         }
 
         // Not a capture wrapper - use parent implementation
@@ -352,6 +388,15 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                     continue; // Try next consumption amount
                 }
 
+                // Evaluate constraint for variadic capture
+                // For variadic captures, constraint receives the entire array of captured elements
+                // The targetCursor is positioned in the target tree (parent context)
+                if (captureMarker.constraint) {
+                    if (!captureMarker.constraint(capturedElements as any, this.targetCursor)) {
+                        continue; // Try next consumption amount
+                    }
+                }
+
                 // Save current state for backtracking
                 const savedState = this.matcher.saveState();
 

package/src/javascript/templating/pattern.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {Cursor} from '../..';
 import {J, Type} from '../../java';
 import {JS} from '../index';
 import {JavaScriptVisitor} from '../visitor';
@@ -181,10 +182,13 @@ export class Pattern {
      * Creates a matcher for this pattern against a specific AST node.
      *
      * @param ast The AST node to match against
-     * @returns A Matcher object
+     * @param cursor Optional cursor at the node's position in a larger tree. Used for context-aware
+     *               capture constraints to navigate to parent nodes. If omitted, a cursor will be
+     *               created at the ast root, allowing constraints to navigate within the matched subtree.
+     * @returns A MatchResult if the pattern matches, undefined otherwise
      */
-    async match(ast: J): Promise<MatchResult | undefined> {
-        const matcher = new Matcher(this, ast);
+    async match(ast: J, cursor?: Cursor): Promise<MatchResult | undefined> {
+        const matcher = new Matcher(this, ast, cursor);
         const success = await matcher.matches();
         if (!success) {
             return undefined;
@@ -301,13 +305,19 @@ class Matcher {
      *
      * @param pattern The pattern to match
      * @param ast The AST node to match against
+     * @param cursor Optional cursor at the AST node's position
      */
     constructor(
         private readonly pattern: Pattern,
-        private readonly ast: J
+        private readonly ast: J,
+        cursor?: Cursor
     ) {
+        // If no cursor provided, create one at the ast root so constraints can navigate up
+        this.cursor = cursor ?? new Cursor(ast, undefined);
     }
 
+    private readonly cursor: Cursor;
+
     /**
      * Checks if the pattern matches the AST node.
      *
@@ -375,18 +385,11 @@ class Matcher {
      * @returns true if the pattern matches the target, false otherwise
      */
     private async matchNode(pattern: J, target: J): Promise<boolean> {
-        // Check if pattern is a capture placeholder
-        if (PlaceholderUtils.isCapture(pattern)) {
-            return this.handleCapture(PlaceholderUtils.getCaptureMarker(pattern)!, target);
-        }
-
-        // Check if nodes have the same kind
-        if (pattern.kind !== target.kind) {
-            return false;
-        }
-
-        // Use the pattern matching comparator with configured lenient type matching
-        // Default to true for backward compatibility with existing patterns
+        // Always delegate to the comparator visitor, which handles:
+        // - Capture detection and constraint evaluation
+        // - Kind checking
+        // - Deep structural comparison
+        // This centralizes all matching logic in one place
         const lenientTypeMatching = this.pattern.options.lenientTypeMatching ?? true;
         const comparator = new PatternMatchingComparator({
             handleCapture: (capture, t, w) => this.handleCapture(capture, t, w),
@@ -394,7 +397,9 @@ class Matcher {
             saveState: () => this.saveState(),
             restoreState: (state) => this.restoreState(state)
         }, lenientTypeMatching);
-        return await comparator.compare(pattern, target);
+        // Pass cursors to allow constraints to navigate to root
+        // Pattern cursor is undefined (pattern is the root), target cursor is provided by user
+        return await comparator.compare(pattern, target, undefined, this.cursor);
     }
 
     /**
@@ -431,14 +436,9 @@ class Matcher {
             return false;
         }
 
-        // Find the original capture object to get constraint and capturing flag
+        // Find the original capture object to get capturing flag
+        // Note: Constraints are now evaluated in PatternMatchingComparator where cursor is correctly positioned
         const captureObj = this.pattern.captures.find(c => c.getName() === captureName);
-        const constraint = captureObj?.getConstraint?.();
-
-        // Apply constraint if present
-        if (constraint && !constraint(target as any)) {
-            return false;
-        }
 
         // Only store the binding if this is a capturing placeholder
         const capturing = (captureObj as any)?.[CAPTURE_CAPTURING_SYMBOL] ?? true;
@@ -465,14 +465,9 @@ class Matcher {
             return false;
         }
 
-        // Find the original capture object to get constraint and capturing flag
+        // Find the original capture object to get capturing flag
+        // Note: Constraints are now evaluated in PatternMatchingComparator where cursor is correctly positioned
         const captureObj = this.pattern.captures.find(c => c.getName() === captureName);
-        const constraint = captureObj?.getConstraint?.();
-
-        // Apply constraint if present - for variadic captures, constraint receives the array of elements
-        if (constraint && !constraint(targets as any)) {
-            return false;
-        }
 
         // Only store the binding if this is a capturing placeholder
         const capturing = (captureObj as any)?.[CAPTURE_CAPTURING_SYMBOL] ?? true;
@@ -514,12 +509,13 @@ class MarkerAttachmentVisitor extends JavaScriptVisitor<undefined> {
         if (ident.simpleName?.startsWith(PlaceholderUtils.CAPTURE_PREFIX)) {
             const captureInfo = PlaceholderUtils.parseCapture(ident.simpleName);
             if (captureInfo) {
-                // Find the original capture object to get variadic options
+                // Find the original capture object to get variadic options and constraint
                 const captureObj = this.captures.find(c => c.getName() === captureInfo.name);
                 const variadicOptions = captureObj?.getVariadicOptions();
+                const constraint = captureObj?.getConstraint?.();
 
-                // Add CaptureMarker to the Identifier
-                const marker = new CaptureMarker(captureInfo.name, variadicOptions);
+                // Add CaptureMarker to the Identifier with constraint
+                const marker = new CaptureMarker(captureInfo.name, variadicOptions, constraint);
                 return updateIfChanged(ident, {
                     markers: {
                         ...ident.markers,

package/src/javascript/templating/rewrite.ts

@@ -25,14 +25,33 @@ import {Template} from './template';
 class RewriteRuleImpl implements RewriteRule {
     constructor(
         private readonly before: Pattern[],
-        private readonly after: Template | ((match: MatchResult) => 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) {
+                // 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') {
@@ -50,7 +69,7 @@ class RewriteRuleImpl implements RewriteRule {
             }
         }
 
-        // Return undefined if no patterns match
+        // Return undefined if no patterns match or all context checks failed
         return undefined;
     }
 
@@ -140,7 +159,12 @@ 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
+    );
 }
 
 /**

package/src/javascript/templating/types.ts

@@ -40,11 +40,41 @@ export interface VariadicOptions {
  * the capture is variadic:
  * - For regular captures: constraint receives a single node of type T
  * - For variadic captures: constraint receives an array of nodes of type T[]
+ *
+ * The constraint function can optionally receive a cursor parameter to perform
+ * context-aware validation during pattern matching.
  */
 export interface CaptureOptions<T = any> {
     name?: string;
     variadic?: boolean | VariadicOptions;
-    constraint?: (node: T) => boolean;
+    /**
+     * Optional constraint function that validates whether a captured node should be accepted.
+     * The function receives:
+     * - node: The captured node (or array of nodes for variadic captures)
+     * - cursor: Optional cursor providing access to the node's context in the AST
+     *
+     * @param node The captured node to validate
+     * @param cursor Optional cursor at the captured node's position
+     * @returns true if the capture should be accepted, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Simple node validation
+     * capture<J.Literal>('size', {
+     *     constraint: (node) => typeof node.value === 'number' && node.value > 100
+     * })
+     *
+     * // Context-aware validation
+     * capture<J.MethodInvocation>('method', {
+     *     constraint: (node, cursor) => {
+     *         if (!node.name.simpleName.startsWith('get')) return false;
+     *         const cls = cursor?.firstEnclosing(isClassDeclaration);
+     *         return cls?.name.simpleName === 'ApiController';
+     *     }
+     * })
+     * ```
+     */
+    constraint?: (node: T, cursor?: Cursor) => boolean;
     /**
      * Type annotation for this capture. When provided, the template engine will generate
      * a preamble declaring the capture identifier with this type annotation, allowing
@@ -101,8 +131,9 @@ export interface Capture<T = any> {
      * Gets the constraint function if this capture has one.
      * For regular captures (T = Expression), constraint receives a single node.
      * For variadic captures (T = Expression[]), constraint receives an array of nodes.
+     * The constraint function can optionally receive a cursor for context-aware validation.
      */
-    getConstraint?(): ((node: T) => boolean) | undefined;
+    getConstraint?(): ((node: T, cursor?: Cursor) => boolean) | undefined;
 }
 
 /**
@@ -367,6 +398,57 @@ export interface RewriteRule {
  * Configuration for a replacement rule.
  */
 export interface RewriteConfig {
-    before: Pattern | Pattern[],
-    after: Template | ((match: MatchResult) => Template)
+    before: Pattern | Pattern[];
+    after: Template | ((match: MatchResult) => Template);
+
+    /**
+     * Optional context predicate that must evaluate to true for the transformation to be applied.
+     * Evaluated after the pattern matches structurally but before applying the template.
+     * Provides access to both the matched node and the cursor for context inspection.
+     *
+     * @param node The matched AST node
+     * @param cursor The cursor at the matched node, providing access to ancestors and context
+     * @returns true if the transformation should be applied, false otherwise
+     *
+     * @example
+     * ```typescript
+     * rewrite(() => ({
+     *     before: pattern`await ${_('promise')}`,
+     *     after: template`await ${_('promise')}.catch(handleError)`,
+     *     where: (node, cursor) => {
+     *         // Only apply inside async functions
+     *         const method = cursor.firstEnclosing((n: any): n is J.MethodDeclaration =>
+     *             n.kind === J.Kind.MethodDeclaration
+     *         );
+     *         return method?.modifiers.some(m => m.type === 'async') || false;
+     *     }
+     * }));
+     * ```
+     */
+    where?: (node: J, cursor: Cursor) => boolean | Promise<boolean>;
+
+    /**
+     * Optional context predicate that must evaluate to false for the transformation to be applied.
+     * Evaluated after the pattern matches structurally but before applying the template.
+     * Provides access to both the matched node and the cursor for context inspection.
+     *
+     * @param node The matched AST node
+     * @param cursor The cursor at the matched node, providing access to ancestors and context
+     * @returns true if the transformation should NOT be applied, false if it should proceed
+     *
+     * @example
+     * ```typescript
+     * rewrite(() => ({
+     *     before: pattern`await ${_('promise')}`,
+     *     after: template`await ${_('promise')}.catch(handleError)`,
+     *     whereNot: (node, cursor) => {
+     *         // Don't apply inside try-catch blocks
+     *         return cursor.firstEnclosing((n: any): n is J.Try =>
+     *             n.kind === J.Kind.Try
+     *         ) !== undefined;
+     *     }
+     * }));
+     * ```
+     */
+    whereNot?: (node: J, cursor: Cursor) => boolean | Promise<boolean>;
 }

package/src/javascript/templating/utils.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {Cursor} from '../..';
 import {J} from '../../java';
 import {JS} from '../index';
 import {JavaScriptParser} from '../parser';
@@ -125,7 +126,8 @@ export class CaptureMarker implements Marker {
 
     constructor(
         public readonly captureName: string,
-        public readonly variadicOptions?: VariadicOptions
+        public readonly variadicOptions?: VariadicOptions,
+        public readonly constraint?: (node: any, cursor?: Cursor) => boolean
     ) {
     }
 }