@openrewrite/rewrite 8.67.0-20251106-160325 → 8.67.0-20251107-103550

package/src/javascript/templating/pattern.ts

@@ -14,16 +14,13 @@
  * limitations under the License.
  */
 import {Cursor} from '../..';
-import {J, Type} from '../../java';
-import {JS} from '../index';
-import {JavaScriptVisitor} from '../visitor';
-import {produceAsync} from '../../visitor';
-import {updateIfChanged} from '../../util';
+import {J} from '../../java';
 import {Any, Capture, PatternOptions} from './types';
-import {CAPTURE_CAPTURING_SYMBOL, CAPTURE_NAME_SYMBOL, CAPTURE_TYPE_SYMBOL, CaptureImpl} from './capture';
+import {CAPTURE_CAPTURING_SYMBOL, CAPTURE_NAME_SYMBOL, CaptureImpl} from './capture';
 import {PatternMatchingComparator} from './comparator';
-import {CaptureMarker, CaptureStorageValue, PlaceholderUtils, templateCache, WRAPPERS_MAP_SYMBOL} from './utils';
-import {isTree, Tree} from "../../tree";
+import {CaptureMarker, CaptureStorageValue, generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
+import {TemplateEngine} from './engine';
+
 
 /**
  * Builder for creating patterns programmatically.
@@ -121,6 +118,7 @@ export class PatternBuilder {
  */
 export class Pattern {
     private _options: PatternOptions = {};
+    private _cachedAstPattern?: J;
 
     /**
      * Gets the configuration options for this pattern.
@@ -175,9 +173,57 @@ export class Pattern {
      */
     configure(options: PatternOptions): Pattern {
         this._options = {...this._options, ...options};
+        // Invalidate cache when configuration changes
+        this._cachedAstPattern = undefined;
         return this;
     }
 
+    /**
+     * Gets the AST pattern for this pattern, using two-level caching:
+     * 1. Instance-level cache (fastest - this pattern instance)
+     * 2. Global LRU cache (fast - shared across pattern instances with same code)
+     * 3. Compute via TemplateProcessor (slow - parse and process)
+     *
+     * @returns The cached or newly computed pattern AST
+     * @internal
+     */
+    async getAstPattern(): Promise<J> {
+        // Level 1: Instance cache (fastest path)
+        if (this._cachedAstPattern) {
+            return this._cachedAstPattern;
+        }
+
+        // Generate cache key for global lookup
+        const contextStatements = this._options.context || this._options.imports || [];
+        const cacheKey = generateCacheKey(
+            this.templateParts,
+            this.captures.map(c => c.getName()).join(','),
+            contextStatements,
+            this._options.dependencies || {}
+        );
+
+        // Level 2: Global cache (fast path - shared with Template)
+        const cached = globalAstCache.get(cacheKey);
+        if (cached) {
+            this._cachedAstPattern = cached;
+            return cached;
+        }
+
+        // Level 3: Compute via TemplateEngine (slow path)
+        const result = await TemplateEngine.getPatternTree(
+            this.templateParts,
+            this.captures,
+            contextStatements,
+            this._options.dependencies || {}
+        );
+
+        // Cache in both levels
+        globalAstCache.set(cacheKey, result);
+        this._cachedAstPattern = result;
+
+        return result;
+    }
+
     /**
      * Creates a matcher for this pattern against a specific AST node.
      *
@@ -325,15 +371,7 @@ class Matcher {
      */
     async matches(): Promise<boolean> {
         if (!this.patternAst) {
-            // Prefer 'context' over deprecated 'imports'
-            const contextStatements = this.pattern.options.context || this.pattern.options.imports || [];
-            const templateProcessor = new TemplateProcessor(
-                this.pattern.templateParts,
-                this.pattern.captures,
-                contextStatements,
-                this.pattern.options.dependencies || {}
-            );
-            this.patternAst = await templateProcessor.toAstPattern();
+            this.patternAst = await this.pattern.getAstPattern();
         }
 
         return this.matchNode(this.patternAst, this.ast);
@@ -484,311 +522,6 @@ class Matcher {
     }
 }
 
-/**
- * Visitor that attaches CaptureMarkers to capture identifiers in the AST.
- * Markers are attached to Identifiers, then moved up to wrappers (RightPadded, ExpressionStatement).
- * Uses JavaScriptVisitor to properly handle AST traversal and avoid cycles in Type objects.
- */
-class MarkerAttachmentVisitor extends JavaScriptVisitor<undefined> {
-    constructor(private readonly captures: (Capture | Any<any>)[]) {
-        super();
-    }
-
-    /**
-     * Attaches CaptureMarker to capture identifiers.
-     */
-    protected override async visitIdentifier(ident: J.Identifier, p: undefined): Promise<J | undefined> {
-        // First call parent to handle standard visitation
-        const visited = await super.visitIdentifier(ident, p);
-        if (!visited || visited.kind !== J.Kind.Identifier) {
-            return visited;
-        }
-        ident = visited as J.Identifier;
-
-        // Check if this is a capture placeholder
-        if (ident.simpleName?.startsWith(PlaceholderUtils.CAPTURE_PREFIX)) {
-            const captureInfo = PlaceholderUtils.parseCapture(ident.simpleName);
-            if (captureInfo) {
-                // 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 with constraint
-                const marker = new CaptureMarker(captureInfo.name, variadicOptions, constraint);
-                return updateIfChanged(ident, {
-                    markers: {
-                        ...ident.markers,
-                        markers: [...ident.markers.markers, marker]
-                    }
-                });
-            }
-        }
-
-        return ident;
-    }
-
-    /**
-     * Propagates markers from element to RightPadded wrapper.
-     */
-    public override async visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: undefined): Promise<J.RightPadded<T>> {
-        if (!isTree(right.element)) {
-            return right;
-        }
-
-        const visitedElement = await this.visit(right.element as J, p);
-        if (visitedElement && visitedElement !== right.element as Tree) {
-            return produceAsync<J.RightPadded<T>>(right, async (draft: any) => {
-                // Visit element first
-                if (right.element && (right.element as any).kind) {
-                    // Check if element has a CaptureMarker
-                    const elementMarker = PlaceholderUtils.getCaptureMarker(visitedElement);
-                    if (elementMarker) {
-                        draft.markers.markers.push(elementMarker);
-                    } else {
-                        draft.element = visitedElement;
-                    }
-                }
-            });
-        }
-
-        return right;
-    }
-
-    /**
-     * Propagates markers from expression to ExpressionStatement.
-     */
-    protected override async visitExpressionStatement(expressionStatement: JS.ExpressionStatement, p: undefined): Promise<J | undefined> {
-        // Visit the expression
-        const visitedExpression = await this.visit(expressionStatement.expression, p);
-
-        // Check if expression has a CaptureMarker
-        const expressionMarker = PlaceholderUtils.getCaptureMarker(visitedExpression as any);
-        if (expressionMarker) {
-            return updateIfChanged(expressionStatement, {
-                markers: {
-                    ...expressionStatement.markers,
-                    markers: [...expressionStatement.markers.markers, expressionMarker]
-                },
-            });
-        }
-
-        // No marker to move, just update with visited expression
-        return updateIfChanged(expressionStatement, {
-            expression: visitedExpression
-        });
-    }
-}
-
-/**
- * Processor for template strings.
- * Converts a template string with captures into an AST pattern.
- */
-class TemplateProcessor {
-    /**
-     * Creates a new template processor.
-     *
-     * @param templateParts The string parts of the template
-     * @param captures The captures between the string parts (can be Capture or Any)
-     * @param contextStatements Context declarations (imports, types, etc.) to prepend for type attribution
-     * @param dependencies NPM dependencies for type attribution
-     */
-    constructor(
-        private readonly templateParts: TemplateStringsArray,
-        private readonly captures: (Capture | Any<any>)[],
-        private readonly contextStatements: string[] = [],
-        private readonly dependencies: Record<string, string> = {}
-    ) {
-    }
-
-    /**
-     * Converts the template to an AST pattern.
-     *
-     * @returns A Promise resolving to the AST pattern
-     */
-    async toAstPattern(): Promise<J> {
-        // Generate type preamble for captures with types
-        const preamble = this.generateTypePreamble();
-
-        // Combine template parts and placeholders
-        const templateString = this.buildTemplateString();
-
-        // Add preamble to context statements (so they're skipped during extraction)
-        const contextWithPreamble = preamble.length > 0
-            ? [...this.contextStatements, ...preamble]
-            : this.contextStatements;
-
-        // Use cache to get or parse the compilation unit
-        const cu = await templateCache.getOrParse(
-            templateString,
-            this.captures,
-            contextWithPreamble,
-            this.dependencies
-        );
-
-        // Extract the relevant part of the AST
-        // The pattern code is always the last statement (after context + preamble)
-        return await this.extractPatternFromAst(cu);
-    }
-
-    /**
-     * Generates type preamble declarations for captures with type annotations.
-     *
-     * @returns Array of preamble statements
-     */
-    private generateTypePreamble(): string[] {
-        const preamble: string[] = [];
-        for (const capture of this.captures) {
-            const captureName = (capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName();
-            const captureType = (capture as any)[CAPTURE_TYPE_SYMBOL];
-            if (captureType) {
-                // Convert Type to string if needed
-                const typeString = typeof captureType === 'string'
-                    ? captureType
-                    : this.typeToString(captureType);
-                const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
-                preamble.push(`let ${placeholder}: ${typeString};`);
-            } else {
-                const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
-                preamble.push(`let ${placeholder};`);
-            }
-        }
-        return preamble;
-    }
-
-    /**
-     * Builds a template string with placeholders for captures.
-     * If the template looks like a block pattern, wraps it in a function.
-     *
-     * @returns The template string
-     */
-    private buildTemplateString(): string {
-        let result = '';
-        for (let i = 0; i < this.templateParts.length; i++) {
-            result += this.templateParts[i];
-            if (i < this.captures.length) {
-                const capture = this.captures[i];
-                // Use symbol to access capture name without triggering Proxy
-                const captureName = (capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName();
-                result += PlaceholderUtils.createCapture(captureName, undefined);
-            }
-        }
-
-        // Check if this looks like a block pattern (starts with { and contains statement keywords)
-        const trimmed = result.trim();
-        if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-            // Check for statement keywords that indicate this is a block, not an object literal
-            const hasStatementKeywords = /\b(return|if|for|while|do|switch|try|throw|break|continue|const|let|var|function|class)\b/.test(result);
-            if (hasStatementKeywords) {
-                // Wrap in a function to ensure it parses as a block
-                return `function __PATTERN__() ${result}`;
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Converts a Type instance to a TypeScript type string.
-     *
-     * @param type The Type instance
-     * @returns A TypeScript type string
-     */
-    private typeToString(type: Type): string {
-        // Handle Type.Class and Type.ShallowClass - return their fully qualified names
-        if (type.kind === Type.Kind.Class || type.kind === Type.Kind.ShallowClass) {
-            const classType = type as Type.Class;
-            return classType.fullyQualifiedName;
-        }
-
-        // Handle Type.Primitive - map to TypeScript primitive types
-        if (type.kind === Type.Kind.Primitive) {
-            const primitiveType = type as Type.Primitive;
-            switch (primitiveType.keyword) {
-                case 'String':
-                    return 'string';
-                case 'boolean':
-                    return 'boolean';
-                case 'double':
-                case 'float':
-                case 'int':
-                case 'long':
-                case 'short':
-                case 'byte':
-                    return 'number';
-                case 'void':
-                    return 'void';
-                default:
-                    return 'any';
-            }
-        }
-
-        // Handle Type.Array - render component type plus []
-        if (type.kind === Type.Kind.Array) {
-            const arrayType = type as Type.Array;
-            const componentTypeString = this.typeToString(arrayType.elemType);
-            return `${componentTypeString}[]`;
-        }
-
-        // For other types, return 'any' as a fallback
-        // TODO: Implement proper Type to string conversion for other Type.Kind values
-        return 'any';
-    }
-
-    /**
-     * Extracts the pattern from the parsed AST.
-     * The pattern code is always the last statement in the compilation unit
-     * (after all context statements and type preamble declarations).
-     *
-     * @param cu The compilation unit
-     * @returns The extracted pattern
-     */
-    private async extractPatternFromAst(cu: JS.CompilationUnit): Promise<J> {
-        // Check if we have any statements
-        if (!cu.statements || cu.statements.length === 0) {
-            throw new Error(`No statements found in compilation unit`);
-        }
-
-        // The pattern code is always the last statement
-        const lastStatement = cu.statements[cu.statements.length - 1].element;
-
-        let extracted: J;
-
-        // Check if this is our wrapper function for block patterns
-        if (lastStatement.kind === J.Kind.MethodDeclaration) {
-            const method = lastStatement as J.MethodDeclaration;
-            if (method.name?.simpleName === '__PATTERN__' && method.body) {
-                // Extract the block from the wrapper function
-                extracted = method.body;
-            } else {
-                extracted = lastStatement;
-            }
-        } else if (lastStatement.kind === JS.Kind.ExpressionStatement) {
-            // If the statement is an expression statement, extract the expression
-            extracted = (lastStatement as JS.ExpressionStatement).expression;
-        } else {
-            // Otherwise, return the statement itself
-            extracted = lastStatement;
-        }
-
-        // Attach CaptureMarkers to capture identifiers
-        return await this.attachCaptureMarkers(extracted);
-    }
-
-    /**
-     * Attaches CaptureMarkers to capture identifiers in the AST.
-     * This allows efficient capture detection without string parsing.
-     * Uses JavaScriptVisitor to properly handle AST traversal and avoid cycles in Type objects.
-     *
-     * @param ast The AST to process
-     * @returns The AST with CaptureMarkers attached
-     */
-    private async attachCaptureMarkers(ast: J): Promise<J> {
-        const visitor = new MarkerAttachmentVisitor(this.captures);
-        return (await visitor.visit(ast, undefined))!;
-    }
-}
-
 /**
  * Tagged template function for creating patterns.
  *

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.

package/src/javascript/templating/rewrite.ts

@@ -121,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

package/src/javascript/templating/template.ts

@@ -15,11 +15,12 @@
  */
 import {Cursor, Tree} from '../..';
 import {J} from '../../java';
-import {TemplateOptions, TemplateParameter, Capture} from './types';
+import {Capture, Parameter, TemplateOptions, TemplateParameter} from './types';
 import {MatchResult} from './pattern';
-import {WRAPPERS_MAP_SYMBOL} from './utils';
+import {generateCacheKey, globalAstCache, WRAPPERS_MAP_SYMBOL} from './utils';
 import {CAPTURE_NAME_SYMBOL} from './capture';
-import {TemplateEngine, Parameter} from './engine';
+import {TemplateEngine} from './engine';
+import {JS} from '..';
 
 /**
  * Coordinates for template application.
@@ -171,6 +172,7 @@ export class TemplateBuilder {
  */
 export class Template {
     private options: TemplateOptions = {};
+    private _cachedTemplate?: J;
 
     /**
      * Creates a new builder for constructing templates programmatically.
@@ -216,9 +218,62 @@ export class Template {
      */
     configure(options: TemplateOptions): Template {
         this.options = { ...this.options, ...options };
+        // Invalidate cache when configuration changes
+        this._cachedTemplate = undefined;
         return this;
     }
 
+    /**
+     * Gets the template tree for this template, using two-level caching:
+     * - Level 1: Instance cache (this._cachedTemplate) - fastest, no lookup needed
+     * - Level 2: Global cache (globalAstCache) - fast, shared across all templates
+     * - Level 3: TemplateEngine - slow, parses and processes the template
+     *
+     * Since all parameters are now placeholders (no primitives), templates with the same
+     * structure always parse to the same AST regardless of parameter values.
+     *
+     * @returns The cached or newly computed template tree
+     * @internal
+     */
+    async getTemplateTree(): Promise<JS.CompilationUnit> {
+        // Level 1: Instance cache (fastest path)
+        if (this._cachedTemplate) {
+            return this._cachedTemplate as JS.CompilationUnit;
+        }
+
+        // Generate cache key for global lookup
+        // Since all parameters use placeholders, we only need the template structure
+        const contextStatements = this.options.context || this.options.imports || [];
+        const parametersKey = this.parameters.length.toString(); // Just the count
+        const cacheKey = generateCacheKey(
+            this.templateParts,
+            parametersKey,
+            contextStatements,
+            this.options.dependencies || {}
+        );
+
+        // Level 2: Global cache (fast path - shared with Pattern)
+        const cached = globalAstCache.get(cacheKey);
+        if (cached) {
+            this._cachedTemplate = cached as JS.CompilationUnit;
+            return cached as JS.CompilationUnit;
+        }
+
+        // Level 3: Compute via TemplateEngine (slow path)
+        const result = await TemplateEngine.getTemplateTree(
+            this.templateParts,
+            this.parameters,
+            contextStatements,
+            this.options.dependencies || {}
+        ) as JS.CompilationUnit;
+
+        // Cache in both levels
+        globalAstCache.set(cacheKey, result);
+        this._cachedTemplate = result;
+
+        return result;
+    }
+
     /**
      * Applies this template and returns the resulting tree.
      *
@@ -263,10 +318,12 @@ export class Template {
             }
         }
 
-        // Prefer 'context' over deprecated 'imports'
-        const contextStatements = this.options.context || this.options.imports || [];
-        return TemplateEngine.applyTemplate(
-            this.templateParts,
+        // Use instance-level cache to get the template tree
+        const ast = await this.getTemplateTree();
+
+        // Delegate to TemplateEngine for placeholder substitution and application
+        return TemplateEngine.applyTemplateFromAst(
+            ast,
             this.parameters,
             cursor,
             {
@@ -274,9 +331,7 @@ export class Template {
                 mode: JavaCoordinates.Mode.Replace
             },
             normalizedValues,
-            wrappersMap,
-            contextStatements,
-            this.options.dependencies || {}
+            wrappersMap
         );
     }
 }
@@ -290,7 +345,7 @@ export class Template {
  * access array elements (e.g., `args.elements[0].element`).
  *
  * @param strings The string parts of the template
- * @param parameters The parameters between the string parts (Capture, Tree, or primitives)
+ * @param parameters The parameters between the string parts (Capture, CaptureValue, TemplateParam, Tree, or Tree[])
  * @returns A Template object that can be applied to generate AST nodes
  *
  * @example

package/src/javascript/templating/types.ts

@@ -15,8 +15,9 @@
  */
 import {Cursor, Tree} from '../..';
 import {J, Type} from '../../java';
-import type {Pattern, MatchResult} from "./pattern";
+import type {MatchResult, Pattern} from "./pattern";
 import type {Template} from "./template";
+import type {CaptureValue} from "./capture";
 
 /**
  * Options for variadic captures that match zero or more nodes in a sequence.
@@ -100,14 +101,14 @@ export interface CaptureOptions<T = any> {
  * but does NOT enforce any runtime constraints on what the capture will match.
  *
  * **Pattern Matching Behavior:**
- * - A bare `pattern`${capture('x')}`` will structurally match ANY expression
- * - Pattern structure determines matching: `pattern`foo(${capture('x')})`` only matches `foo()` calls
+ * - A bare `pattern`${capture()}`` will structurally match ANY expression
+ * - Pattern structure determines matching: `pattern`foo(${capture()})`` only matches `foo()` calls with one arg
  * - Use structural patterns to narrow matching scope before applying semantic validation
  *
  * **Variadic Captures:**
  * Use `{ variadic: true }` to match zero or more nodes in a sequence:
  * ```typescript
- * const args = capture('args', { variadic: true });
+ * const args = capture({ variadic: true });
  * pattern`foo(${args})`  // Matches: foo(), foo(a), foo(a, b, c)
  * ```
  */
@@ -168,8 +169,9 @@ export interface Capture<T = any> {
  *
  * @example
  * // Variadic any - match zero or more without capturing
+ * const first = any();
  * const rest = any({ variadic: true });
- * const pat = pattern`bar(${capture('first')}, ${rest})`
+ * const pat = pattern`bar(${first}, ${rest})`
  *
  * @example
  * // With constraints - validate but don't capture
@@ -273,11 +275,30 @@ export interface PatternOptions {
  * Valid parameter types for template literals.
  * - Capture: For pattern matching and reuse
  * - CaptureValue: Result of property access or array operations on captures (e.g., capture.prop, capture[0], capture.slice(1))
+ * - TemplateParam: For standalone template parameters
  * - Tree: AST nodes to be inserted directly
  * - Tree[]: Arrays of AST nodes (from variadic capture operations like slice)
- * - Primitives: Values to be converted to literals
+ *
+ * Note: Primitive values (string, number, boolean) are NOT supported in template literals.
+ * Use Template.builder() API if you need to insert literal values.
  */
-export type TemplateParameter = Capture | any | TemplateParam | Tree | Tree[] | string | number | boolean;
+export type TemplateParameter = Capture | CaptureValue | TemplateParam | Tree | Tree[];
+
+/**
+ * Parameter specification for template generation (internal).
+ * Represents a placeholder in a template that will be replaced with a parameter value.
+ * This is the internal wrapper used by the template engine.
+ *
+ * Note: The value is typed as `any` rather than `TemplateParameter` to allow flexible
+ * internal handling without excessive type guards. The public API (template function)
+ * constrains inputs to `TemplateParameter`, providing type safety at the API boundary.
+ */
+export interface Parameter {
+    /**
+     * The value to substitute into the template.
+     */
+    value: any;
+}
 
 /**
  * Configuration options for templates.
@@ -347,18 +368,21 @@ export interface RewriteRule {
      *
      * @example
      * ```typescript
-     * const rule1 = rewrite(() => ({
-     *     before: pattern`${capture('a')} + ${capture('b')}`,
-     *     after: template`${capture('b')} + ${capture('a')}`
-     * }));
+     * const rule1 = rewrite(() => {
+     *     const { a, b } = { a: capture(), b: capture() };
+     *     return {
+     *         before: pattern`${a} + ${b}`,
+     *         after: template`${b} + ${a}`
+     *     };
+     * });
      *
      * const rule2 = rewrite(() => ({
      *     before: pattern`${capture('x')} + 1`,
-     *     after: template`${capture('x')} + 2`
+     *     after: template`${capture('x')}++`
      * }));
      *
      * const combined = rule1.andThen(rule2);
-     * // Will first swap operands, then if result matches "x + 1", change to "x + 2"
+     * // Will first swap operands, then if result matches "x + 1", change to "x++"
      * ```
      */
     andThen(next: RewriteRule): RewriteRule;