@openrewrite/rewrite 8.66.0 → 8.66.2

package/dist/javascript/templating/rewrite.d.ts

@@ -0,0 +1,84 @@
+import { ExecutionContext, Recipe } from '../..';
+import { RewriteRule, RewriteConfig } from './types';
+/**
+ * Creates a replacement rule using a capture context and configuration.
+ *
+ * @param builderFn Function that takes a capture context and returns before/after configuration
+ * @returns A replacement rule that can be applied to AST nodes
+ *
+ * @example
+ * // Single pattern
+ * 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(() => {
+ *     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
+ * class MyVisitor extends JavaScriptVisitor<any> {
+ *     override async visitBinary(binary: J.Binary, p: any): Promise<J | undefined> {
+ *         const rule = rewrite(() => ({
+ *             before: pattern`${capture('a')} + ${capture('b')}`,
+ *             after: template`${capture('b')} + ${capture('a')}`
+ *         }));
+ *         // tryOn() returns undefined if no pattern matches, so always use || node
+ *         return await rule.tryOn(this.cursor, binary) || binary;
+ *     }
+ * }
+ */
+export declare function rewrite(builderFn: () => RewriteConfig): RewriteRule;
+/**
+ * Creates a RewriteRule from a Recipe by using its editor visitor.
+ *
+ * This allows recipes to be used in the same chaining pattern as other rewrite rules,
+ * enabling composition with `andThen()`.
+ *
+ * @param recipe The recipe whose editor will be used to transform nodes
+ * @param ctx The execution context to pass to the recipe's editor
+ * @returns A RewriteRule that applies the recipe's editor to nodes
+ *
+ * @example
+ * ```typescript
+ * class MyRecipe extends Recipe {
+ *     name = "my.recipe";
+ *     displayName = "My Recipe";
+ *     description = "Transforms code.";
+ *
+ *     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+ *         return new MyVisitor();
+ *     }
+ * }
+ *
+ * // In a visitor:
+ * override async visitBinary(binary: J.Binary, p: ExecutionContext): Promise<J | undefined> {
+ *     const rule1 = rewrite(() => ({
+ *         before: pattern`${capture('a')} + ${capture('b')}`,
+ *         after: template`${capture('b')} + ${capture('a')}`
+ *     }));
+ *
+ *     const rule2 = fromRecipe(new MyRecipe(), p);
+ *
+ *     // Chain the pattern-based rule with the recipe
+ *     const combined = rule1.andThen(rule2);
+ *     return await combined.tryOn(this.cursor, binary) || binary;
+ * }
+ * ```
+ */
+export declare const fromRecipe: (recipe: Recipe, ctx: ExecutionContext) => RewriteRule;
+//# sourceMappingURL=rewrite.d.ts.map

package/dist/javascript/templating/rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/rewrite.ts"],"names":[],"mappings":"AAeA,OAAO,EAAS,gBAAgB,EAAE,MAAM,EAAC,MAAM,OAAO,CAAC;AAEvD,OAAO,EAAC,WAAW,EAAE,aAAa,EAAC,MAAM,SAAS,CAAC;AAkGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,OAAO,CACnB,SAAS,EAAE,MAAM,aAAa,GAC/B,WAAW,CAcb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,EAAE,KAAK,gBAAgB,KAAG,WAgBlE,CAAA"}

package/dist/javascript/templating/rewrite.js

@@ -0,0 +1,208 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromRecipe = void 0;
+exports.rewrite = rewrite;
+/**
+ * Implementation of a replacement rule.
+ */
+class RewriteRuleImpl {
+    constructor(before, after, where, whereNot) {
+        this.before = before;
+        this.after = after;
+        this.where = where;
+        this.whereNot = whereNot;
+    }
+    tryOn(cursor, node) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const pattern of this.before) {
+                // Pass cursor to pattern.match() for context-aware capture constraints
+                const match = yield pattern.match(node, cursor);
+                if (match) {
+                    // Evaluate context predicates after structural match
+                    if (this.where) {
+                        const whereResult = yield this.where(node, cursor);
+                        if (!whereResult) {
+                            continue; // Pattern matched but context doesn't, try next pattern
+                        }
+                    }
+                    if (this.whereNot) {
+                        const whereNotResult = yield this.whereNot(node, cursor);
+                        if (whereNotResult) {
+                            continue; // Pattern matched but context is excluded, try next pattern
+                        }
+                    }
+                    // Apply transformation
+                    let result;
+                    if (typeof this.after === 'function') {
+                        // Call the function to get a template, then apply it
+                        const template = this.after(match);
+                        result = yield template.apply(cursor, node, match);
+                    }
+                    else {
+                        // Use template.apply() as before
+                        result = yield this.after.apply(cursor, node, match);
+                    }
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+            // Return undefined if no patterns match or all context checks failed
+            return undefined;
+        });
+    }
+    andThen(next) {
+        const first = this;
+        return new (class extends RewriteRuleImpl {
+            constructor() {
+                // Pass empty patterns and a function that will never be called
+                // since we override tryOn
+                super([], () => undefined);
+            }
+            tryOn(cursor, node) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const firstResult = yield first.tryOn(cursor, node);
+                    if (firstResult !== undefined) {
+                        const secondResult = yield next.tryOn(cursor, firstResult);
+                        return secondResult !== null && secondResult !== void 0 ? secondResult : firstResult;
+                    }
+                    return undefined;
+                });
+            }
+        })();
+    }
+    orElse(alternative) {
+        const first = this;
+        return new (class extends RewriteRuleImpl {
+            constructor() {
+                // Pass empty patterns and a function that will never be called
+                // since we override tryOn
+                super([], () => undefined);
+            }
+            tryOn(cursor, node) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const firstResult = yield first.tryOn(cursor, node);
+                    if (firstResult !== undefined) {
+                        return firstResult;
+                    }
+                    return yield alternative.tryOn(cursor, node);
+                });
+            }
+        })();
+    }
+}
+/**
+ * Creates a replacement rule using a capture context and configuration.
+ *
+ * @param builderFn Function that takes a capture context and returns before/after configuration
+ * @returns A replacement rule that can be applied to AST nodes
+ *
+ * @example
+ * // Single pattern
+ * 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(() => {
+ *     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
+ * class MyVisitor extends JavaScriptVisitor<any> {
+ *     override async visitBinary(binary: J.Binary, p: any): Promise<J | undefined> {
+ *         const rule = rewrite(() => ({
+ *             before: pattern`${capture('a')} + ${capture('b')}`,
+ *             after: template`${capture('b')} + ${capture('a')}`
+ *         }));
+ *         // tryOn() returns undefined if no pattern matches, so always use || node
+ *         return await rule.tryOn(this.cursor, binary) || binary;
+ *     }
+ * }
+ */
+function rewrite(builderFn) {
+    const config = builderFn();
+    // Ensure we have valid before and after properties
+    if (!config.before || !config.after) {
+        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, config.where, config.whereNot);
+}
+/**
+ * Creates a RewriteRule from a Recipe by using its editor visitor.
+ *
+ * This allows recipes to be used in the same chaining pattern as other rewrite rules,
+ * enabling composition with `andThen()`.
+ *
+ * @param recipe The recipe whose editor will be used to transform nodes
+ * @param ctx The execution context to pass to the recipe's editor
+ * @returns A RewriteRule that applies the recipe's editor to nodes
+ *
+ * @example
+ * ```typescript
+ * class MyRecipe extends Recipe {
+ *     name = "my.recipe";
+ *     displayName = "My Recipe";
+ *     description = "Transforms code.";
+ *
+ *     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+ *         return new MyVisitor();
+ *     }
+ * }
+ *
+ * // In a visitor:
+ * override async visitBinary(binary: J.Binary, p: ExecutionContext): Promise<J | undefined> {
+ *     const rule1 = rewrite(() => ({
+ *         before: pattern`${capture('a')} + ${capture('b')}`,
+ *         after: template`${capture('b')} + ${capture('a')}`
+ *     }));
+ *
+ *     const rule2 = fromRecipe(new MyRecipe(), p);
+ *
+ *     // Chain the pattern-based rule with the recipe
+ *     const combined = rule1.andThen(rule2);
+ *     return await combined.tryOn(this.cursor, binary) || binary;
+ * }
+ * ```
+ */
+const fromRecipe = (recipe, ctx) => {
+    return new (class extends RewriteRuleImpl {
+        constructor() {
+            // Pass empty patterns and a function that will never be called
+            // since we override tryOn
+            super([], () => undefined);
+        }
+        tryOn(cursor, tree) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const visitor = yield recipe.editor();
+                const result = yield visitor.visit(tree, ctx, cursor);
+                // Return undefined if the visitor didn't change the node
+                return result !== tree ? result : undefined;
+            });
+        }
+    })();
+};
+exports.fromRecipe = fromRecipe;
+//# sourceMappingURL=rewrite.js.map

package/dist/javascript/templating/rewrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewrite.js","sourceRoot":"","sources":["../../../src/javascript/templating/rewrite.ts"],"names":[],"mappings":"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"}

package/dist/javascript/templating/template.d.ts

@@ -0,0 +1,230 @@
+import { Cursor, Tree } from '../..';
+import { J } from '../../java';
+import { Capture, Parameter, TemplateOptions, TemplateParameter } from './types';
+import { JS } from '..';
+/**
+ * Coordinates for template application.
+ */
+type JavaCoordinates = {
+    tree?: Tree;
+    loc?: JavaCoordinates.Location;
+    mode?: JavaCoordinates.Mode;
+};
+declare namespace JavaCoordinates {
+    type Location = 'EXPRESSION_PREFIX' | 'STATEMENT_PREFIX' | 'BLOCK_END';
+    enum Mode {
+        Before = 0,
+        After = 1,
+        Replace = 2
+    }
+}
+/**
+ * Builder for creating templates programmatically.
+ * Use when template structure is not known at compile time.
+ *
+ * @example
+ * // Conditional construction
+ * const builder = Template.builder().code('function foo(x) {');
+ * if (needsValidation) {
+ *     builder.code('if (typeof x !== "number") throw new Error("Invalid");');
+ * }
+ * builder.code('return x * 2; }');
+ * const tmpl = builder.build();
+ *
+ * @example
+ * // Composition from fragments
+ * function createWrapper(innerBody: Capture): Template {
+ *     return Template.builder()
+ *         .code('function wrapper() { try { ')
+ *         .param(innerBody)
+ *         .code(' } catch(e) { console.error(e); } }')
+ *         .build();
+ * }
+ */
+export declare class TemplateBuilder {
+    private parts;
+    private params;
+    /**
+     * Adds a static string part to the template.
+     *
+     * @param str The string to add
+     * @returns This builder for chaining
+     */
+    code(str: string): this;
+    /**
+     * Adds a parameter to the template.
+     *
+     * @param value The parameter value (Capture, Tree, or primitive)
+     * @returns This builder for chaining
+     */
+    param(value: TemplateParameter): this;
+    /**
+     * Builds the template from accumulated parts and parameters.
+     *
+     * @returns A Template instance
+     */
+    build(): Template;
+}
+/**
+ * Template for creating AST nodes.
+ *
+ * This class provides the public API for template generation.
+ * The actual templating logic is handled by the internal TemplateEngine.
+ *
+ * Templates can reference captures from patterns, and you can access properties
+ * of captured nodes using dot notation. This allows you to extract and insert
+ * specific subtrees from matched AST nodes.
+ *
+ * @example
+ * // Generate a literal AST node
+ * const result = template`2`.apply(cursor, coordinates);
+ *
+ * @example
+ * // Generate an AST node with a parameter
+ * const result = template`${capture()}`.apply(cursor, coordinates);
+ *
+ * @example
+ * // Access properties of captured nodes in templates
+ * const method = capture<J.MethodInvocation>('method');
+ * const pat = pattern`foo(${method})`;
+ * const tmpl = template`bar(${method.name})`; // Access the 'name' property
+ *
+ * const match = await pat.match(someNode);
+ * if (match) {
+ *     // The template will insert just the 'name' subtree from the captured method
+ *     const result = await tmpl.apply(cursor, someNode, match);
+ * }
+ *
+ * @example
+ * // Deep property access chains
+ * const method = capture<J.MethodInvocation>('method');
+ * template`console.log(${method.name.simpleName})` // Navigate multiple properties
+ *
+ * @example
+ * // Array element access
+ * const invocation = capture<J.MethodInvocation>('invocation');
+ * template`bar(${invocation.arguments.elements[0].element})` // Access array elements
+ */
+export declare class Template {
+    private readonly templateParts;
+    private readonly parameters;
+    private options;
+    private _cachedTemplate?;
+    /**
+     * Creates a new builder for constructing templates programmatically.
+     *
+     * @returns A new TemplateBuilder instance
+     *
+     * @example
+     * const tmpl = Template.builder()
+     *     .code('function foo() {')
+     *     .code('return ')
+     *     .param(capture('value'))
+     *     .code('; }')
+     *     .build();
+     */
+    static builder(): TemplateBuilder;
+    /**
+     * Creates a new template.
+     *
+     * @param templateParts The string parts of the template
+     * @param parameters The parameters between the string parts
+     */
+    constructor(templateParts: TemplateStringsArray, parameters: Parameter[]);
+    /**
+     * Configures this template with additional options.
+     *
+     * @param options Configuration options
+     * @returns This template for method chaining
+     *
+     * @example
+     * template`isDate(${capture('date')})`
+     *     .configure({
+     *         context: ['import { isDate } from "util"'],
+     *         dependencies: { 'util': '^1.0.0' }
+     *     })
+     */
+    configure(options: TemplateOptions): Template;
+    /**
+     * 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
+     *
+     * Most parameters use placeholders that are replaced during application, so templates
+     * with the same structure share cached ASTs. However, raw() parameters are spliced at
+     * construction time, so their values must be included in the cache key.
+     *
+     * @returns The cached or newly computed template tree
+     * @internal
+     */
+    getTemplateTree(): Promise<JS.CompilationUnit>;
+    /**
+     * Applies this template and returns the resulting tree.
+     *
+     * @param cursor The cursor pointing to the current location in the AST
+     * @param tree Input tree
+     * @param values values for parameters in template
+     * @returns A Promise resolving to the generated AST node
+     */
+    apply(cursor: Cursor, tree: J, values?: Map<Capture | string, J> | Pick<Map<string, J>, 'get'> | Record<string, J>): Promise<J | undefined>;
+}
+/**
+ * Tagged template function for creating templates that generate AST nodes.
+ *
+ * Templates support property access on captures from patterns, allowing you to
+ * extract and insert specific subtrees from matched AST nodes. Use dot notation
+ * to navigate properties (e.g., `method.name`) or array bracket notation to
+ * access array elements (e.g., `args.elements[0].element`).
+ *
+ * Templates can also accept AST wrapper types directly:
+ * - J.RightPadded<T>: The element will be extracted and inserted
+ * - J.RightPadded<T>[]: Elements will be expanded in place
+ * - J.Container<T>: Elements will be expanded in place
+ *
+ * @param strings The string parts of the template
+ * @param parameters The parameters between the string parts (Capture, CaptureValue, TemplateParam, Tree, Tree[], J.RightPadded, J.RightPadded[], or J.Container)
+ * @returns A Template object that can be applied to generate AST nodes
+ *
+ * @example
+ * // Simple template with literal
+ * const tmpl = template`console.log("hello")`;
+ * const result = await tmpl.apply(cursor, node);
+ *
+ * @example
+ * // Template with capture - matches captured value from pattern
+ * const expr = capture('expr');
+ * const pat = pattern`foo(${expr})`;
+ * const tmpl = template`bar(${expr})`;
+ *
+ * const match = await pat.match(node);
+ * if (match) {
+ *     const result = await tmpl.apply(cursor, node, match);
+ * }
+ *
+ * @example
+ * // Property access on captures - extract subtrees
+ * const method = capture<J.MethodInvocation>('method');
+ * const pat = pattern`foo(${method})`;
+ * // Access the 'name' property of the captured method invocation
+ * const tmpl = template`bar(${method.name})`;
+ *
+ * @example
+ * // Deep property chains
+ * const method = capture<J.MethodInvocation>('method');
+ * template`console.log(${method.name.simpleName})`
+ *
+ * @example
+ * // Array element access
+ * const invocation = capture<J.MethodInvocation>('invocation');
+ * template`bar(${invocation.arguments.elements[0].element})`
+ *
+ * @example
+ * // Using J.RightPadded and J.Container directly
+ * const selectExpr = method.select;  // J.RightPadded<Expression>
+ * const args = method.arguments;      // J.Container<Expression>
+ * template`${selectExpr}.newMethod(${args})`
+ */
+export declare function template(strings: TemplateStringsArray, ...parameters: TemplateParameter[]): Template;
+export type { JavaCoordinates };
+//# sourceMappingURL=template.d.ts.map

package/dist/javascript/templating/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../../src/javascript/templating/template.ts"],"names":[],"mappings":"AAeA,OAAO,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,OAAO,CAAC;AACnC,OAAO,EAAC,CAAC,EAAC,MAAM,YAAY,CAAC;AAC7B,OAAO,EAAC,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,iBAAiB,EAAC,MAAM,SAAS,CAAC;AAK/E,OAAO,EAAC,EAAE,EAAC,MAAM,IAAI,CAAC;AAEtB;;GAEG;AACH,KAAK,eAAe,GAAG;IACnB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,GAAG,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC;IAC/B,IAAI,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC;CAC/B,CAAC;AAEF,kBAAU,eAAe,CAAC;IAEtB,KAAY,QAAQ,GAAG,mBAAmB,GAAG,kBAAkB,GAAG,WAAW,CAAC;IAE9E,KAAY,IAAI;QACZ,MAAM,IAAA;QACN,KAAK,IAAA;QACL,OAAO,IAAA;KACV;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,MAAM,CAA2B;IAEzC;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAcvB;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAWrC;;;;OAIG;IACH,KAAK,IAAI,QAAQ;CAiBpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,QAAQ;IA4Bb,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU;IA5B/B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,eAAe,CAAC,CAAI;IAE5B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,OAAO,IAAI,eAAe;IAIjC;;;;;OAKG;gBAEkB,aAAa,EAAE,oBAAoB,EACnC,UAAU,EAAE,SAAS,EAAE;IAI5C;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ;IAO7C;;;;;;;;;;;;OAYG;IACG,eAAe,IAAI,OAAO,CAAC,EAAE,CAAC,eAAe,CAAC;IA+CpD;;;;;;;OAOG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,OAAO,GAAG,MAAM,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CAoDpJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,UAAU,EAAE,iBAAiB,EAAE,GAAG,QAAQ,CAQpG;AAED,YAAY,EAAC,eAAe,EAAC,CAAC"}