@openrewrite/rewrite 8.66.0 → 8.66.1

package/src/javascript/templating/comparator.ts

@@ -0,0 +1,430 @@
+/*
+ * 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 {Cursor, Tree} from '../..';
+import {J} from '../../java';
+import {JS} from '../index';
+import {JavaScriptSemanticComparatorVisitor} from '../comparator';
+import {PlaceholderUtils, CaptureStorageValue} from './utils';
+
+/**
+ * A comparator for pattern matching that is lenient about optional properties.
+ * Allows patterns without type annotations to match actual code with type annotations.
+ * Uses semantic comparison to match semantically equivalent code (e.g., isDate() and util.isDate()).
+ */
+export class PatternMatchingComparator extends JavaScriptSemanticComparatorVisitor {
+    constructor(
+        private readonly matcher: {
+            handleCapture: (pattern: J, target: J, wrapper?: J.RightPadded<J>) => boolean;
+            handleVariadicCapture: (pattern: J, targets: J[], wrappers?: J.RightPadded<J>[]) => boolean;
+            saveState: () => Map<string, CaptureStorageValue>;
+            restoreState: (state: Map<string, CaptureStorageValue>) => void;
+        },
+        lenientTypeMatching: boolean = true
+    ) {
+        // Enable lenient type matching based on pattern configuration (default: true for backward compatibility)
+        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
+        if (PlaceholderUtils.isCapture(j as J)) {
+            const wrapper = this.getWrapperFromCursor(this.cursor);
+            const success = this.matcher.handleCapture(j as J, p, wrapper);
+            if (!success) {
+                return this.abort(j) as R;
+            }
+            return j as R;
+        }
+
+        if (!this.match) {
+            return j as R;
+        }
+
+        return 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));
+    }
+
+    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);
+        }
+        return super.visitIdentifier(identifier, other);
+    }
+
+    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)
+        );
+
+        // If no variadic captures, use parent implementation (which includes semantic/type-aware matching)
+        if (!hasVariadicCapture) {
+            return super.visitMethodInvocation(methodInvocation, other);
+        }
+
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match || other.kind !== J.Kind.MethodInvocation) {
+            return this.abort(methodInvocation);
+        }
+
+        const otherMethodInvocation = other as J.MethodInvocation;
+
+        // Compare select
+        if ((methodInvocation.select === undefined) !== (otherMethodInvocation.select === undefined)) {
+            return this.abort(methodInvocation);
+        }
+
+        // Visit select if present
+        if (methodInvocation.select && otherMethodInvocation.select) {
+            await this.visit(methodInvocation.select.element, otherMethodInvocation.select.element);
+            if (!this.match) return methodInvocation;
+        }
+
+        // Compare typeParameters
+        if ((methodInvocation.typeParameters === undefined) !== (otherMethodInvocation.typeParameters === undefined)) {
+            return this.abort(methodInvocation);
+        }
+
+        // Visit typeParameters if present
+        if (methodInvocation.typeParameters && otherMethodInvocation.typeParameters) {
+            if (methodInvocation.typeParameters.elements.length !== otherMethodInvocation.typeParameters.elements.length) {
+                return this.abort(methodInvocation);
+            }
+
+            // Visit each type parameter in lock step
+            for (let i = 0; i < methodInvocation.typeParameters.elements.length; i++) {
+                await this.visit(methodInvocation.typeParameters.elements[i].element, otherMethodInvocation.typeParameters.elements[i].element);
+                if (!this.match) return methodInvocation;
+            }
+        }
+
+        // Visit name
+        await this.visit(methodInvocation.name, otherMethodInvocation.name);
+        if (!this.match) return methodInvocation;
+
+        // Special handling for variadic captures in arguments
+        if (!await this.matchArguments(methodInvocation.arguments.elements, otherMethodInvocation.arguments.elements)) {
+            return this.abort(methodInvocation);
+        }
+
+        return methodInvocation;
+    }
+
+    override async visitBlock(block: J.Block, other: J): Promise<J | undefined> {
+        // Check if any statements have CaptureMarker indicating they're variadic
+        const hasVariadicCapture = block.statements.some(stmt => {
+            const captureMarker = PlaceholderUtils.getCaptureMarker(stmt.element);
+            return captureMarker?.variadicOptions !== undefined;
+        });
+
+        // If no variadic captures, use parent implementation
+        if (!hasVariadicCapture) {
+            return super.visitBlock(block, other);
+        }
+
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match || other.kind !== J.Kind.Block) {
+            return this.abort(block);
+        }
+
+        const otherBlock = other as J.Block;
+
+        // Special handling for variadic captures in statements
+        if (!await this.matchSequence(block.statements, otherBlock.statements, false)) {
+            return this.abort(block);
+        }
+
+        return block;
+    }
+
+    override async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, other: J): Promise<J | undefined> {
+        // Check if any statements are variadic captures (unwrap ExpressionStatement wrappers first)
+        const hasVariadicCapture = compilationUnit.statements.some(stmt => {
+            const unwrapped = PlaceholderUtils.unwrapStatementCapture(stmt.element);
+            return PlaceholderUtils.isVariadicCapture(unwrapped);
+        });
+
+        // If no variadic captures, use parent implementation
+        if (!hasVariadicCapture) {
+            return super.visitJsCompilationUnit(compilationUnit, other);
+        }
+
+        // Otherwise, handle variadic captures ourselves
+        if (!this.match || other.kind !== JS.Kind.CompilationUnit) {
+            return this.abort(compilationUnit);
+        }
+
+        const otherCompilationUnit = other as JS.CompilationUnit;
+
+        // Special handling for variadic captures in top-level statements
+        if (!await this.matchSequence(compilationUnit.statements, otherCompilationUnit.statements, false)) {
+            return this.abort(compilationUnit);
+        }
+
+        return compilationUnit;
+    }
+
+    /**
+     * Matches argument lists, with special handling for variadic captures.
+     * A variadic capture can match zero or more consecutive arguments.
+     */
+    private async matchArguments(patternArgs: J.RightPadded<J>[], targetArgs: J.RightPadded<J>[]): Promise<boolean> {
+        return this.matchSequence(patternArgs, targetArgs, true);
+    }
+
+    /**
+     * Generic sequence matching with variadic capture support.
+     * Works for any sequence of JRightPadded elements (arguments, statements, etc.).
+     * A variadic capture can match zero or more consecutive elements.
+     *
+     * Uses pivot detection to optimize matching, with backtracking as fallback.
+     *
+     * @param patternElements The pattern elements (JRightPadded)
+     * @param targetElements The target elements to match against (JRightPadded)
+     * @param filterEmpty Whether to filter out J.Empty elements when capturing (true for arguments, false for statements)
+     * @returns true if the sequence matches, false otherwise
+     */
+    private async matchSequence(patternElements: J.RightPadded<J>[], targetElements: J.RightPadded<J>[], filterEmpty: boolean): Promise<boolean> {
+        return await this.matchSequenceOptimized(patternElements, targetElements, 0, 0, filterEmpty);
+    }
+
+    /**
+     * Optimized sequence matcher with pivot detection and backtracking.
+     * For variadic patterns, tries to detect pivots (where next pattern matches) to avoid
+     * unnecessary backtracking. Falls back to full backtracking when pivots are ambiguous.
+     *
+     * @param patternElements The pattern elements (JRightPadded)
+     * @param targetElements The target elements to match against (JRightPadded)
+     * @param patternIdx Current position in pattern
+     * @param targetIdx Current position in target
+     * @param filterEmpty Whether to filter out J.Empty elements when capturing
+     * @returns true if the remaining sequence matches, false otherwise
+     */
+    private async matchSequenceOptimized(
+        patternElements: J.RightPadded<J>[],
+        targetElements: J.RightPadded<J>[],
+        patternIdx: number,
+        targetIdx: number,
+        filterEmpty: boolean
+    ): Promise<boolean> {
+        // Base case: all patterns matched
+        if (patternIdx >= patternElements.length) {
+            return targetIdx >= targetElements.length; // Success if all targets consumed
+        }
+
+        const patternElement = patternElements[patternIdx].element;
+        const captureMarker = PlaceholderUtils.getCaptureMarker(patternElement);
+        const isVariadic = captureMarker?.variadicOptions !== undefined;
+
+        if (isVariadic) {
+            // Variadic pattern: try different consumption amounts with backtracking
+            const variadicOptions = captureMarker!.variadicOptions;
+            const min = variadicOptions?.min ?? 0;
+            const max = variadicOptions?.max ?? Infinity;
+
+            // Calculate maximum possible consumption
+            let nonVariadicRemainingPatterns = 0;
+            for (let i = patternIdx + 1; i < patternElements.length; i++) {
+                const nextPatternElement = patternElements[i].element;
+                const nextCaptureMarker = PlaceholderUtils.getCaptureMarker(nextPatternElement);
+                const nextIsVariadic = nextCaptureMarker?.variadicOptions !== undefined;
+                if (!nextIsVariadic) {
+                    nonVariadicRemainingPatterns++;
+                }
+            }
+            const remainingTargetElements = targetElements.length - targetIdx;
+            const maxPossible = Math.min(remainingTargetElements - nonVariadicRemainingPatterns, max);
+
+            // Pivot detection optimization: try to find where next pattern matches
+            // This avoids unnecessary backtracking when constraints make the split point obvious
+            let pivotDetected = false;
+            let pivotAt = -1;
+
+            if (patternIdx + 1 < patternElements.length && min <= maxPossible) {
+                const nextPattern = patternElements[patternIdx + 1].element;
+
+                // Scan through possible consumption amounts starting from min
+                for (let tryConsume = min; tryConsume <= maxPossible; tryConsume++) {
+                    // Check if element after our consumption would match next pattern
+                    if (targetIdx + tryConsume < targetElements.length) {
+                        const candidateElement = targetElements[targetIdx + tryConsume].element;
+
+                        // Skip J.Empty for arguments
+                        if (filterEmpty && candidateElement.kind === J.Kind.Empty) {
+                            continue;
+                        }
+
+                        // Test if next pattern matches this element
+                        const savedMatch = this.match;
+                        const savedState = this.matcher.saveState();
+
+                        await this.visit(nextPattern, candidateElement);
+                        const matchesNext = this.match;
+
+                        this.match = savedMatch;
+                        this.matcher.restoreState(savedState);
+
+                        if (matchesNext) {
+                            // Found pivot! Try this consumption amount first
+                            pivotDetected = true;
+                            pivotAt = tryConsume;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // Try different consumption amounts
+            // If pivot detected, try that first; otherwise use greedy approach (max to min)
+            const consumptionOrder: number[] = [];
+            if (pivotDetected && pivotAt >= 0) {
+                // Try pivot first, then others as fallback
+                consumptionOrder.push(pivotAt);
+                for (let c = maxPossible; c >= min; c--) {
+                    if (c !== pivotAt) {
+                        consumptionOrder.push(c);
+                    }
+                }
+            } else {
+                // Greedy approach: max to min
+                for (let c = maxPossible; c >= min; c--) {
+                    consumptionOrder.push(c);
+                }
+            }
+
+            for (const consume of consumptionOrder) {
+                // Capture elements for this consumption amount
+                const capturedWrappers: J.RightPadded<J>[] = [];
+                for (let i = 0; i < consume; i++) {
+                    const wrapped = targetElements[targetIdx + i];
+                    const element = wrapped.element;
+                    // For arguments, filter out J.Empty as it represents an empty argument list
+                    // For statements, include all elements
+                    if (!filterEmpty || element.kind !== J.Kind.Empty) {
+                        capturedWrappers.push(wrapped);
+                    }
+                }
+
+                // Extract just the elements for the constraint check
+                const capturedElements: J[] = capturedWrappers.map(w => w.element);
+
+                // Re-check min/max constraints against actual captured elements (after filtering if applicable)
+                if (capturedElements.length < min || capturedElements.length > max) {
+                    continue; // Try next consumption amount
+                }
+
+                // Save current state for backtracking
+                const savedState = this.matcher.saveState();
+
+                // Handle the variadic capture
+                const success = this.matcher.handleVariadicCapture(patternElement, capturedElements, capturedWrappers);
+                if (!success) {
+                    // Restore state and try next amount
+                    this.matcher.restoreState(savedState);
+                    continue;
+                }
+
+                // Try to match the rest of the pattern
+                const restMatches = await this.matchSequenceOptimized(
+                    patternElements,
+                    targetElements,
+                    patternIdx + 1,
+                    targetIdx + consume,
+                    filterEmpty
+                );
+
+                if (restMatches) {
+                    return true; // Found a valid matching
+                }
+
+                // Backtrack: restore state and try next amount
+                this.matcher.restoreState(savedState);
+            }
+
+            return false; // No consumption amount worked
+        } else {
+            // Regular non-variadic element - must match exactly one target element
+            if (targetIdx >= targetElements.length) {
+                return false; // Pattern has more elements than target
+            }
+
+            const targetWrapper = targetElements[targetIdx];
+            const targetElement = targetWrapper.element;
+
+            // For arguments, J.Empty represents no argument, so regular captures should not match it
+            if (filterEmpty && targetElement.kind === J.Kind.Empty) {
+                return false;
+            }
+
+            // Save current state for backtracking (both match state and capture bindings)
+            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;
+            }
+            if (!this.match) {
+                // Restore state on match failure
+                this.match = savedMatch;
+                this.matcher.restoreState(savedState);
+                return false;
+            }
+
+            // Continue matching the rest
+            const restMatches = await this.matchSequenceOptimized(
+                patternElements,
+                targetElements,
+                patternIdx + 1,
+                targetIdx + 1,
+                filterEmpty
+            );
+
+            if (!restMatches) {
+                // Restore full state on backtracking failure
+                this.match = savedMatch;
+                this.matcher.restoreState(savedState);
+            }
+
+            return restMatches;
+        }
+    }
+}

package/src/javascript/templating/engine.ts

@@ -0,0 +1,252 @@
+/*
+ * 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 {Cursor, isTree} from '../..';
+import {J} from '../../java';
+import {JS} from '..';
+import {produce} from 'immer';
+import {TemplateCache, PlaceholderUtils} from './utils';
+import {CaptureImpl, TemplateParamImpl, CaptureValue, CAPTURE_NAME_SYMBOL} from './capture';
+import {PlaceholderReplacementVisitor} from './placeholder-replacement';
+import {JavaCoordinates} from './template';
+
+/**
+ * Cache for compiled templates.
+ */
+const templateCache = new TemplateCache();
+
+/**
+ * Parameter specification for template generation.
+ * Represents a placeholder in a template that will be replaced with a parameter value.
+ */
+export interface Parameter {
+    /**
+     * The value to substitute into the template.
+     */
+    value: any;
+}
+
+/**
+ * Internal template engine - handles the core templating logic.
+ * Not exported from index, so only visible within the templating module.
+ */
+export class TemplateEngine {
+    /**
+     * Applies a template with optional match results from pattern matching.
+     *
+     * @param templateParts The string parts of the template
+     * @param parameters The parameters between the string parts
+     * @param cursor The cursor pointing to the current location in the AST
+     * @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 contextStatements Context declarations (imports, types, etc.) to prepend for type attribution
+     * @param dependencies NPM dependencies for type attribution
+     * @returns A Promise resolving to the generated AST node
+     */
+    static async applyTemplate(
+        templateParts: TemplateStringsArray,
+        parameters: Parameter[],
+        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(),
+        contextStatements: string[] = [],
+        dependencies: Record<string, string> = {}
+    ): Promise<J | undefined> {
+        // Build the template string with parameter placeholders
+        const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
+
+        // If the template string is empty, return undefined
+        if (!templateString.trim()) {
+            return undefined;
+        }
+
+        // Use cache to get or parse the compilation unit
+        // For templates, we don't have captures, so use empty array
+        const cu = await templateCache.getOrParse(
+            templateString,
+            [], // templates don't have captures in the cache key
+            contextStatements,
+            dependencies
+        );
+
+        // Check if there are any statements
+        if (!cu.statements || cu.statements.length === 0) {
+            throw new Error(`Failed to parse template code (no statements):\n${templateString}`);
+        }
+
+        // Skip context statements to get to the actual template code
+        const templateStatementIndex = contextStatements.length;
+        if (templateStatementIndex >= cu.statements.length) {
+            return undefined;
+        }
+
+        // Extract the relevant part of the AST
+        const firstStatement = cu.statements[templateStatementIndex].element;
+        let extracted: J;
+
+        // Check if this is a wrapped template (function __TEMPLATE__() { ... })
+        if (firstStatement.kind === J.Kind.MethodDeclaration) {
+            const func = firstStatement as J.MethodDeclaration;
+            if (func.name.simpleName === '__TEMPLATE__' && func.body) {
+                // __TEMPLATE__ wrapper indicates the original template was a block.
+                // Always return the block to preserve the block structure.
+                extracted = func.body;
+            } else {
+                // Not a __TEMPLATE__ wrapper
+                extracted = firstStatement;
+            }
+        } else if (firstStatement.kind === JS.Kind.ExpressionStatement) {
+            extracted = (firstStatement as JS.ExpressionStatement).expression;
+        } else {
+            extracted = firstStatement;
+        }
+
+        // Create a copy to avoid sharing cached AST instances
+        const ast = produce(extracted, _ => {});
+
+        // Create substitutions map for placeholders
+        const substitutions = new Map<string, Parameter>();
+        for (let i = 0; i < parameters.length; i++) {
+            const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
+            substitutions.set(placeholder, parameters[i]);
+        }
+
+        // Unsubstitute placeholders with actual parameter values and match results
+        const visitor = new PlaceholderReplacementVisitor(substitutions, values, wrappersMap);
+        const unsubstitutedAst = (await visitor.visit(ast, null))!;
+
+        // Apply the template to the current AST
+        return new TemplateApplier(cursor, coordinates, unsubstitutedAst).apply();
+    }
+
+    /**
+     * Builds a template string with parameter placeholders.
+     *
+     * @param templateParts The string parts of the template
+     * @param parameters The parameters between the string parts
+     * @returns The template string
+     */
+    private static buildTemplateString(
+        templateParts: TemplateStringsArray,
+        parameters: Parameter[]
+    ): string {
+        let result = '';
+        for (let i = 0; i < templateParts.length; i++) {
+            result += templateParts[i];
+            if (i < parameters.length) {
+                const param = parameters[i].value;
+                // Use a placeholder for Captures, TemplateParams, CaptureValues, Tree nodes, and Tree arrays
+                // Inline everything else (strings, numbers, booleans) directly
+                // Check for Capture (could be a Proxy, so check for symbol property)
+                const isCapture = param instanceof CaptureImpl ||
+                                (param && typeof param === 'object' && param[CAPTURE_NAME_SYMBOL]);
+                const isTemplateParam = param instanceof TemplateParamImpl;
+                const isCaptureValue = param instanceof CaptureValue;
+                const isTreeArray = Array.isArray(param) && param.length > 0 && isTree(param[0]);
+                if (isCapture || isTemplateParam || isCaptureValue || isTree(param) || isTreeArray) {
+                    const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
+                    result += placeholder;
+                } else {
+                    result += param;
+                }
+            }
+        }
+
+        // Detect if this is a block template that needs wrapping
+        const trimmed = result.trim();
+        if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
+            result = `function __TEMPLATE__() ${result}`;
+        }
+
+        return result;
+    }
+}
+
+/**
+ * Helper class for applying a template to an AST.
+ */
+export class TemplateApplier {
+    constructor(
+        private readonly cursor: Cursor,
+        private readonly coordinates: JavaCoordinates,
+        private readonly ast: J
+    ) {
+    }
+
+    /**
+     * Applies the template to the current AST.
+     *
+     * @returns A Promise resolving to the modified AST
+     */
+    async apply(): Promise<J | undefined> {
+        const {loc} = this.coordinates;
+
+        // Apply the template based on the location and mode
+        switch (loc || 'EXPRESSION_PREFIX') {
+            case 'EXPRESSION_PREFIX':
+                return this.applyToExpression();
+            case 'STATEMENT_PREFIX':
+                return this.applyToStatement();
+            case 'BLOCK_END':
+                return this.applyToBlock();
+            default:
+                throw new Error(`Unsupported location: ${loc}`);
+        }
+    }
+
+    /**
+     * Applies the template to an expression.
+     *
+     * @returns A Promise resolving to the modified AST
+     */
+    private async applyToExpression(): Promise<J | undefined> {
+        const {tree} = this.coordinates;
+
+        // Create a copy of the AST with the prefix from the target
+        return tree ? produce(this.ast, draft => {
+            draft.prefix = (tree as J).prefix;
+        }) : this.ast;
+    }
+
+    /**
+     * Applies the template to a statement.
+     *
+     * @returns A Promise resolving to the modified AST
+     */
+    private async applyToStatement(): Promise<J | undefined> {
+        const {tree} = this.coordinates;
+
+        // Create a copy of the AST with the prefix from the target
+        return produce(this.ast, draft => {
+            draft.prefix = (tree as J).prefix;
+        });
+    }
+
+    /**
+     * Applies the template to a block.
+     *
+     * @returns A Promise resolving to the modified AST
+     */
+    private async applyToBlock(): Promise<J | undefined> {
+        const {tree} = this.coordinates;
+
+        // Create a copy of the AST with the prefix from the target
+        return produce(this.ast, draft => {
+            draft.prefix = (tree as J).prefix;
+        });
+    }
+}