@openrewrite/rewrite 8.91.0 → 8.91.1

package/src/javascript/templating/bindings.ts

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {J, Type} from '../../java';
+import {JavaScriptVisitor} from '../visitor';
+import {Cursor} from '../../tree';
+import {ModuleBinding} from './types';
+
+/**
+ * Whether the template's dependencies bring a workspace that could resolve `module`.
+ */
+export function isResolvable(module: string, dependencies: Record<string, string>): boolean {
+    const segments = module.split('/');
+    const pkg = module.startsWith('@') ? segments.slice(0, 2).join('/') : segments[0];
+    return Object.prototype.hasOwnProperty.call(dependencies, pkg);
+}
+
+/**
+ * What a declared binding's name is parsed against, ahead of the template and so out of its output.
+ * An import is what carries attribution, and costs a module resolution to get it; a declaration
+ * names the binding for a module no workspace could have resolved anyway.
+ */
+export function bindingContextStatement(name: string, binding: ModuleBinding, dependencies: Record<string, string>): string {
+    if (!isResolvable(binding.module, dependencies)) {
+        return binding.typeOnly ? `type ${name} = any;` : `declare const ${name}: any;`;
+    }
+    const type = binding.typeOnly ? 'type ' : '';
+    if (binding.member === '*') {
+        return `import ${type}* as ${name} from '${binding.module}';`;
+    }
+    if (binding.member === undefined || binding.member === 'default') {
+        return `import ${type}${name} from '${binding.module}';`;
+    }
+    const specifier = binding.member === name ? name : `${binding.member} as ${name}`;
+    return `import ${type}{${specifier}} from '${binding.module}';`;
+}
+
+/**
+ * Renames the identifiers a template uses for its declared bindings to the names the file
+ * actually binds. Runs before parameter substitution, so only the template's own code is in
+ * scope and a caller's captured code is never rewritten.
+ */
+export async function renameBindings<T extends J>(tree: T, renames: Record<string, string>, modules: Record<string, string>): Promise<T> {
+    return new RenameBindingsVisitor(renames, modules).visit(tree, undefined) as Promise<T>;
+}
+
+class RenameBindingsVisitor extends JavaScriptVisitor<undefined> {
+    constructor(private readonly renames: Record<string, string>,
+                private readonly modules: Record<string, string>) {
+        super();
+    }
+
+    override async visitIdentifier(identifier: J.Identifier, p: undefined): Promise<J | undefined> {
+        const renamed = this.renames[identifier.simpleName];
+        if (renamed === undefined || renamed === identifier.simpleName) {
+            return identifier;
+        }
+
+        // Attribution settles it where the context import resolved. It is absent for a module the
+        // parse could not reach, and the identifier's position decides instead.
+        const resolved = resolvedModule(identifier);
+        const refersToBinding = resolved !== undefined
+            ? resolved === this.modules[identifier.simpleName]
+            : !namesItsParent(this.cursor, identifier);
+
+        return refersToBinding ? {...identifier, simpleName: renamed} as J.Identifier : identifier;
+    }
+}
+
+/** Whether the parent is naming this identifier — as a property, a method, a declaration — rather than referencing it. */
+function namesItsParent(cursor: Cursor, identifier: J.Identifier): boolean {
+    let c: Cursor | undefined = cursor.parent;
+    while (c && isPadding(c.value)) {
+        c = c.parent;
+    }
+    const parent = c?.value as { kind?: string; name?: unknown; select?: unknown } | undefined;
+
+    // A call names a member of whatever it selects from. With nothing selected there is no member,
+    // and its `name` is a reference to the function being called.
+    if (parent?.kind === J.Kind.MethodInvocation && !parent.select) {
+        return false;
+    }
+
+    const name = parent?.name;
+    return name === identifier || (name as { element?: unknown } | undefined)?.element === identifier;
+}
+
+function isPadding(value: unknown): boolean {
+    const kind = (value as { kind?: string } | undefined)?.kind;
+    return kind === J.Kind.RightPadded || kind === J.Kind.LeftPadded || kind === J.Kind.Container;
+}
+
+/** The module an identifier's attribution traces back to, following the owning-class chain to its root. */
+function resolvedModule(identifier: J.Identifier): string | undefined {
+    const fieldType = identifier.fieldType;
+    if (fieldType?.kind === Type.Kind.Variable) {
+        const owner = (fieldType as Type.Variable).owner;
+        return owner && Type.isClass(owner) ? rootName(owner as Type.Class) : undefined;
+    }
+    const type = identifier.type;
+    if (type && Type.isMethod(type)) {
+        const declaring = (type as Type.Method).declaringType;
+        return declaring ? rootName(declaring as Type.Class) : undefined;
+    }
+    if (type && Type.isClass(type)) {
+        return rootName(type as Type.Class);
+    }
+    return undefined;
+}
+
+function rootName(classType: Type.Class): string {
+    let current: Type.Class = classType;
+    while (current.owningClass && Type.isClass(current.owningClass)) {
+        current = current.owningClass as Type.Class;
+    }
+    return Type.FullyQualified.getFullyQualifiedName(current);
+}

package/src/javascript/templating/comparator.ts

@@ -344,13 +344,12 @@ export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisit
                 if (!this.match) return methodInvocation;
             }
 
-            // Compare typeParameters
-            if ((methodInvocation.typeParameters === undefined) !== (otherMethodInvocation.typeParameters === undefined)) {
-                return this.structuralMismatch('typeParameters');
-            }
+            // A pattern that spells out no type arguments says nothing about them, as with parentheses
+            if (methodInvocation.typeParameters) {
+                if (!otherMethodInvocation.typeParameters) {
+                    return this.structuralMismatch('typeParameters');
+                }
 
-            // Visit typeParameters if present
-            if (methodInvocation.typeParameters && otherMethodInvocation.typeParameters) {
                 if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
                     return this.arrayLengthMismatch('typeParameters.elements');
                 }

package/src/javascript/templating/engine.ts

@@ -17,12 +17,13 @@ import {Cursor, isTree, produceAsync, Tree, updateIfChanged} from '../..';
 import {emptySpace, J, Statement, Type} from '../../java';
 import {Any, Capture, JavaScriptParser, JavaScriptVisitor, JS} from '..';
 import {create as produce} from 'mutative';
-import {CaptureMarker, PlaceholderUtils, randomizeIds, retainIds, treeIds, WRAPPER_FUNCTION_NAME} from './utils';
+import {CaptureMarker, dedentTemplate, PlaceholderUtils, randomizeIds, retainIds, treeIds, WRAPPER_FUNCTION_NAME} from './utils';
 import {CAPTURE_NAME_SYMBOL, CAPTURE_TYPE_SYMBOL, CaptureImpl, CaptureValue, RAW_CODE_SYMBOL, RawCode} from './capture';
 import {PlaceholderReplacementVisitor} from './placeholder-replacement';
 import {maybeParenthesize, parenthesize, requiredPrecedence, startsWithDeclarationToken} from './precedence';
 import {JavaCoordinates} from './template';
 import {maybeAutoFormat} from '../format';
+import {renameBindings} from './bindings';
 import {isExpression, isStatement} from '../parser-utils';
 import {randomId} from '../../uuid';
 import ts from "typescript";
@@ -82,6 +83,21 @@ let templateSourceFileCache: Map<string, ts.SourceFile> | undefined;
  */
 export function setTemplateSourceFileCache(cache?: Map<string, ts.SourceFile>): void {
     templateSourceFileCache = cache;
+    templateParsers.clear();
+}
+
+// Every template parses under `template.tsx`, so one parser per workspace carries its program
+// from one compile to the next; see `JavaScriptParser.parse`.
+const templateParsers: Map<string, JavaScriptParser> = new Map();
+
+function templateParser(workspaceDir?: string): JavaScriptParser {
+    const key = workspaceDir ?? "";
+    let parser = templateParsers.get(key);
+    if (!parser) {
+        parser = new JavaScriptParser({relativeTo: workspaceDir, sourceFileCache: templateSourceFileCache});
+        templateParsers.set(key, parser);
+    }
+    return parser;
 }
 
 /**
@@ -147,10 +163,7 @@ class TemplateCache {
 
         // Parse and cache (workspace only needed during parsing)
         // Use templateSourceFileCache if configured for ~3.2x speedup on dependency file parsing
-        const parser = new JavaScriptParser({
-            relativeTo: workspaceDir,
-            sourceFileCache: templateSourceFileCache
-        });
+        const parser = templateParser(workspaceDir);
         const parseGenerator = parser.parse({text: fullTemplateString, sourcePath: 'template.tsx'});
         cu = (await parseGenerator.next()).value as JS.CompilationUnit;
 
@@ -202,7 +215,7 @@ export class TemplateEngine {
         dependencies: Record<string, string> = {}
     ): Promise<J> {
         // Generate type preamble for captures/parameters with types
-        const preamble = TemplateEngine.generateTypePreamble(parameters);
+        const preamble = TemplateEngine.parameterPreamble(parameters);
 
         // Build the template string with parameter placeholders
         const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
@@ -244,6 +257,9 @@ export class TemplateEngine {
      * @param coordinates The coordinates specifying where and how to insert the generated AST
      * @param values Map of capture names to values to replace the parameters with
      * @param wrappersMap Map of capture names to J.RightPadded wrappers (for preserving markers)
+     * @param format Whether to fit the result to where it lands
+     * @param renames Local names for the template's declared bindings, keyed as declared
+     * @param modules The module each declared binding names, keyed as declared
      * @returns A Promise resolving to the generated AST node
      */
     static async applyTemplateFromAst(
@@ -252,7 +268,10 @@ export class TemplateEngine {
         cursor: Cursor,
         coordinates: JavaCoordinates,
         values: Pick<Map<string, J>, 'get'> = new Map(),
-        wrappersMap: Pick<Map<string, J.RightPadded<J> | J.RightPadded<J>[]>, 'get'> = new Map()
+        wrappersMap: Pick<Map<string, J.RightPadded<J> | J.RightPadded<J>[]>, 'get'> = new Map(),
+        format: boolean = true,
+        renames: Record<string, string> = {},
+        modules: Record<string, string> = {}
     ): Promise<J | undefined> {
         // Create substitutions map for placeholders
         const substitutions = new Map<string, Parameter>();
@@ -264,9 +283,13 @@ export class TemplateEngine {
         // Before substitution, so that ids carried over from the source tree survive this pass
         const fresh = await randomizeIds(ast);
 
+        const bound = Object.keys(renames).length > 0
+            ? await renameBindings(fresh.tree as J, renames, modules)
+            : fresh.tree;
+
         // Unsubstitute placeholders with actual parameter values and match results
         const visitor = new PlaceholderReplacementVisitor(substitutions, values, wrappersMap);
-        const unsubstitutedAst = (await visitor.visit(fresh.tree, null))!;
+        const unsubstitutedAst = (await visitor.visit(bound, null))!;
 
         // An id may only be kept where the node answering to it is leaving the tree, which is the
         // subtree this application replaces. A parameter named twice, or spliced in from somewhere
@@ -280,7 +303,7 @@ export class TemplateEngine {
         const uniqueAst = await retainIds(unsubstitutedAst, retainable);
 
         // Apply the template to the current AST
-        return new TemplateApplier(cursor, coordinates, uniqueAst).apply();
+        return new TemplateApplier(cursor, coordinates, uniqueAst, format).apply();
     }
 
     /**
@@ -289,7 +312,33 @@ export class TemplateEngine {
      * @param parameters The parameters
      * @returns Array of preamble statements
      */
-    private static generateTypePreamble(parameters: Parameter[]): string[] {
+    /** The declarations that give a capture's placeholder its type while the pattern is parsed. */
+    static capturePreamble(captures: (Capture | Any | RawCode)[]): string[] {
+        const preamble: string[] = [];
+        for (const capture of captures) {
+            // Raw code is spliced in as source, so it declares nothing
+            if (capture instanceof RawCode || (capture && typeof capture === 'object' && (capture as any)[RAW_CODE_SYMBOL])) {
+                continue;
+            }
+
+            const captureName = (capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName();
+            const captureType = (capture as any)[CAPTURE_TYPE_SYMBOL];
+            if (captureType) {
+                const typeString = typeof captureType === 'string'
+                    ? captureType
+                    : this.typeToString(captureType);
+                // `any` attributes nothing, so a declaration for it would only cost a parse
+                if (typeString !== 'any') {
+                    const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
+                    preamble.push(`let ${placeholder}: ${typeString};`);
+                }
+            }
+        }
+        return preamble;
+    }
+
+    /** The parameter counterpart of {@link capturePreamble}. */
+    static parameterPreamble(parameters: Parameter[]): string[] {
         const preamble: string[] = [];
 
         for (let i = 0; i < parameters.length; i++) {
@@ -377,7 +426,7 @@ export class TemplateEngine {
 
         // Always wrap in function body - let the parser decide what it is,
         // then we'll extract intelligently based on what was parsed
-        return `function ${WRAPPER_FUNCTION_NAME}() { ${result} }`;
+        return `function ${WRAPPER_FUNCTION_NAME}() { ${dedentTemplate(result)} }`;
     }
 
     /**
@@ -428,15 +477,14 @@ export class TemplateEngine {
     }
 
     /**
-     * Gets the parsed and extracted pattern tree with capture markers attached.
-     * This is the entry point for pattern processing, providing pattern-specific
-     * functionality on top of the shared template tree generation.
+     * Gets the parsed and extracted pattern tree, with placeholder identifiers left bare;
+     * `attachCaptureMarkers` binds it to a particular set of captures.
      *
      * @param templateParts The string parts of the template
      * @param captures The captures between the string parts (can include RawCode)
      * @param contextStatements Context declarations (imports, types, etc.) to prepend for type attribution
      * @param dependencies NPM dependencies for type attribution
-     * @returns A Promise resolving to the extracted pattern AST with capture markers
+     * @returns A Promise resolving to the extracted pattern AST
      */
     static async getPatternTree(
         templateParts: TemplateStringsArray,
@@ -444,29 +492,7 @@ export class TemplateEngine {
         contextStatements: string[] = [],
         dependencies: Record<string, string> = {}
     ): Promise<J> {
-        // Generate type preamble for captures with types (skip RawCode)
-        const preamble: string[] = [];
-        for (const capture of captures) {
-            // Skip raw code - it's not a capture
-            if (capture instanceof RawCode || (capture && typeof capture === 'object' && (capture as any)[RAW_CODE_SYMBOL])) {
-                continue;
-            }
-
-            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);
-                // Only add preamble if we have a concrete type (not 'any')
-                if (typeString !== 'any') {
-                    const placeholder = PlaceholderUtils.createCapture(captureName, undefined);
-                    preamble.push(`let ${placeholder}: ${typeString};`);
-                }
-            }
-            // Don't add preamble declarations without types - they don't provide type attribution
-        }
+        const preamble = TemplateEngine.capturePreamble(captures);
 
         // Build the template string with placeholders for captures and raw code
         let result = '';
@@ -517,18 +543,25 @@ export class TemplateEngine {
         const lastStatement = cu.statements[cu.statements.length - 1].element;
 
         // Extract from wrapper using shared utility
-        const extracted = PlaceholderUtils.extractFromWrapper(lastStatement, 'Pattern');
+        return PlaceholderUtils.extractFromWrapper(lastStatement, 'Pattern');
+    }
 
-        // Attach CaptureMarkers to capture identifiers (only for actual captures, not raw code)
-        const visitor = new MarkerAttachmentVisitor(actualCaptures);
-        return (await visitor.visit(extracted, undefined))!;
+    /**
+     * Binds a pattern tree to a set of captures by attaching a CaptureMarker, carrying that
+     * capture's constraint and variadic options, to each placeholder identifier.
+     */
+    static async attachCaptureMarkers(tree: J, captures: (Capture | Any | RawCode)[]): Promise<J> {
+        const actualCaptures = captures.filter(c =>
+            !(c instanceof RawCode || (c && typeof c === 'object' && (c as any)[RAW_CODE_SYMBOL]))
+        ) as (Capture | Any)[];
+        return (await new MarkerAttachmentVisitor(actualCaptures).visit(tree, undefined))!;
     }
 }
 
 /**
  * Visitor that attaches CaptureMarkers to capture identifiers in pattern ASTs.
  * This allows efficient capture detection without string parsing during matching.
- * Used by TemplateEngine.getPatternTree() for pattern-specific processing.
+ * Reached through TemplateEngine.attachCaptureMarkers().
  */
 class MarkerAttachmentVisitor extends JavaScriptVisitor<undefined> {
     constructor(private readonly captures: (Capture | Any)[]) {
@@ -656,7 +689,8 @@ export class TemplateApplier {
     constructor(
         private readonly cursor: Cursor,
         private readonly coordinates: JavaCoordinates,
-        private readonly ast: J
+        private readonly ast: J,
+        private readonly shouldFormat: boolean = true
     ) {
     }
 
@@ -738,6 +772,10 @@ export class TemplateApplier {
             prefix: originalTree.prefix
         };
 
+        if (!this.shouldFormat) {
+            return {...result, id: resultToUse.id};
+        }
+
         // Apply auto-formatting to the result
         const formatted =
             await maybeAutoFormat(originalTree, result, null, undefined, this.cursor?.parent);

package/src/javascript/templating/index.ts

@@ -25,7 +25,9 @@ export type {
     MatchOptions,
     TemplateParameter,
     TemplateOptions,
+    ModuleBinding,
     RewriteRule,
+    TryOnOptions,
     RewriteConfig,
     DebugOptions,
     DebugLogEntry,

package/src/javascript/templating/pattern.ts

@@ -233,27 +233,28 @@ export class Pattern {
         const cacheKey = generateCacheKey(
             this.templateParts,
             capturesKey,
-            contextStatements,
+            // A capture's type reaches the parse as a declaration, so it shapes the tree the same
+            // way an explicit context statement does and belongs in the key alongside one.
+            [...contextStatements, ...TemplateEngine.capturePreamble(this.captures)],
             this._options.dependencies || {}
         );
 
         // Level 2: Global cache (fast path - shared with Template)
-        const cached = globalAstCache.get(cacheKey);
-        if (cached) {
-            this._cachedAstPattern = cached;
-            return cached;
+        let tree = globalAstCache.get(cacheKey);
+        if (!tree) {
+            // Level 3: Compute via TemplateEngine (slow path)
+            tree = await TemplateEngine.getPatternTree(
+                this.templateParts,
+                this.captures,
+                contextStatements,
+                this._options.dependencies || {}
+            );
+            globalAstCache.set(cacheKey, tree);
         }
 
-        // 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);
+        // The key names captures but says nothing about their constraints, so two patterns of the
+        // same shape share an entry; markers are attached per instance to keep them apart.
+        const result = await TemplateEngine.attachCaptureMarkers(tree, this.captures);
         this._cachedAstPattern = result;
 
         return result;

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

@@ -82,8 +82,8 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             return super.visitContainer(container, p);
         }
 
-        // Expand variadic placeholders in the container's elements
-        const newElements = await this.expandVariadicElements(container.elements, undefined, p);
+        // A container's element layout is the author's; a block lays its statements out by indentation
+        const newElements = await this.expandVariadicElements(container.elements, undefined, p, true);
 
         return produce(container, draft => {
             draft.elements = newElements as any;
@@ -175,6 +175,12 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
         };
     }
 
+    /** As `mergePrefix`, but a line break the source wrote and the template did not is the source's layout. */
+    private mergeElementPrefix(sourcePrefix: J.Space, templatePrefix: J.Space): J.Space {
+        return sourcePrefix.whitespace.includes('\n') && !templatePrefix.whitespace.includes('\n') ?
+            sourcePrefix : this.mergePrefix(sourcePrefix, templatePrefix);
+    }
+
     /**
      * Expands variadic placeholders in a list of elements.
      *
@@ -186,7 +192,8 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
     private async expandVariadicElements(
         elements: J.RightPadded<J>[],
         unwrapElement: (element: J) => J = (e) => e,
-        p: any
+        p: any,
+        ownLayout: boolean = false
     ): Promise<J.RightPadded<J>[]> {
         const newElements: J.RightPadded<J>[] = [];
 
@@ -263,7 +270,9 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                                             if (i === 0 && draft.element) {
                                                 // Merge the placeholder's prefix with the first item's prefix
                                                 // Modify prefix directly within the draft
-                                                draft.element.prefix = this.mergePrefix(draft.element.prefix, element.prefix);
+                                                draft.element.prefix = ownLayout ?
+                                                    this.mergeElementPrefix(draft.element.prefix, element.prefix) :
+                                                    this.mergePrefix(draft.element.prefix, element.prefix);
                                             }
                                             // Keep all other wrapper properties (including markers with Semicolon)
                                         }));
@@ -273,7 +282,9 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                                         newElements.push(produce(wrapped, draft => {
                                             draft.element = produce(elem, itemDraft => {
                                                 if (i === 0) {
-                                                    itemDraft.prefix = this.mergePrefix(elem.prefix, element.prefix);
+                                                    itemDraft.prefix = ownLayout ?
+                                                        this.mergeElementPrefix(elem.prefix, element.prefix) :
+                                                        this.mergePrefix(elem.prefix, element.prefix);
                                                 }
                                                 // For i > 0, prefix is already correct, no changes needed
                                             });

package/src/javascript/templating/rewrite.ts

@@ -15,7 +15,7 @@
  */
 import {Cursor, ExecutionContext, Recipe, TreeVisitor} from '../..';
 import {J, Statement} from '../../java';
-import {PostMatchContext, PreMatchContext, RewriteConfig, RewriteRule} from './types';
+import {PostMatchContext, PreMatchContext, RewriteConfig, RewriteRule, TryOnOptions} from './types';
 import {MatchResult, Pattern} from './pattern';
 import {Template} from './template';
 import {JavaScriptVisitor} from '../visitor';
@@ -28,11 +28,12 @@ class RewriteRuleImpl implements RewriteRule {
         private readonly before: Pattern[],
         private readonly after: Template | ((match: MatchResult) => Template),
         private readonly preMatch?: (node: J, context: PreMatchContext) => boolean | Promise<boolean>,
-        private readonly postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>
+        private readonly postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>,
+        private readonly format?: boolean
     ) {
     }
 
-    async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
+    async tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined> {
         // Evaluate preMatch before attempting any pattern matching
         if (this.preMatch) {
             const preMatchResult = await this.preMatch(node, { cursor });
@@ -56,14 +57,10 @@ class RewriteRuleImpl implements RewriteRule {
                 // 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(node, cursor, { values: match });
-                } else {
-                    // Use template.apply() as before
-                    result = await this.after.apply(node, cursor, { values: match });
-                }
+                const template = typeof this.after === 'function' ? this.after(match) : this.after;
+                const bindings = options?.bindings ?? (options?.visitor && template.resolveBindings(options.visitor));
+                result = await template.apply(node, cursor,
+                    { values: match, format: this.format, bindings: bindings || undefined });
 
                 if (result) {
                     return result;
@@ -84,10 +81,10 @@ class RewriteRuleImpl implements RewriteRule {
                 super([], () => undefined as unknown as Template);
             }
 
-            async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
-                const firstResult = await first.tryOn(cursor, node);
+            async tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined> {
+                const firstResult = await first.tryOn(cursor, node, options);
                 if (firstResult !== undefined) {
-                    const secondResult = await next.tryOn(cursor, firstResult);
+                    const secondResult = await next.tryOn(cursor, firstResult, options);
                     return secondResult ?? firstResult;
                 }
                 return undefined;
@@ -104,12 +101,12 @@ class RewriteRuleImpl implements RewriteRule {
                 super([], () => undefined as unknown as Template);
             }
 
-            async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
-                const firstResult = await first.tryOn(cursor, node);
+            async tryOn(cursor: Cursor, node: J, options?: TryOnOptions): Promise<J | undefined> {
+                const firstResult = await first.tryOn(cursor, node, options);
                 if (firstResult !== undefined) {
                     return firstResult;
                 }
-                return await alternative.tryOn(cursor, node);
+                return await alternative.tryOn(cursor, node, options);
             }
         })();
     }
@@ -171,7 +168,8 @@ export function rewrite(
         Array.isArray(config.before) ? config.before : [config.before],
         config.after,
         config.preMatch,
-        config.postMatch
+        config.postMatch,
+        config.format
     );
 }