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

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/template.ts

@@ -15,11 +15,11 @@
  */
 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';
 
 /**
  * Coordinates for template application.
@@ -171,6 +171,7 @@ export class TemplateBuilder {
  */
 export class Template {
     private options: TemplateOptions = {};
+    private _cachedTemplate?: J;
 
     /**
      * Creates a new builder for constructing templates programmatically.
@@ -216,9 +217,55 @@ export class Template {
      */
     configure(options: TemplateOptions): Template {
         this.options = { ...this.options, ...options };
+        // Invalidate cache when configuration changes
+        this._cachedTemplate = undefined;
         return this;
     }
 
+    /**
+     * Gets the cached template tree or computes it.
+     * Uses two-level caching: instance cache → global cache → compute.
+     *
+     * @returns A Promise resolving to the template AST tree
+     */
+    private async getTemplate(): Promise<J> {
+        // Level 1: Instance cache (fastest path)
+        if (this._cachedTemplate) {
+            return this._cachedTemplate;
+        }
+
+        // Generate cache key for global lookup
+        const contextStatements = this.options.context || this.options.imports || [];
+        const paramNames = this.parameters.map((p, i) => `param${i}`).join(',');
+        const cacheKey = generateCacheKey(
+            this.templateParts,
+            paramNames,
+            contextStatements,
+            this.options.dependencies || {}
+        );
+
+        // Level 2: Global cache (fast path - shared with Pattern)
+        const cached = globalAstCache.get(cacheKey);
+        if (cached) {
+            this._cachedTemplate = cached;
+            return cached;
+        }
+
+        // Level 3: Compute via TemplateEngine (slow path)
+        const result = await TemplateEngine.getTemplateTree(
+            this.templateParts,
+            this.parameters,
+            contextStatements,
+            this.options.dependencies || {}
+        );
+
+        // Cache in both levels
+        globalAstCache.set(cacheKey, result);
+        this._cachedTemplate = result;
+
+        return result;
+    }
+
     /**
      * Applies this template and returns the resulting tree.
      *
@@ -263,8 +310,15 @@ export class Template {
             }
         }
 
+        // Get the cached template tree (uses two-level caching)
+        const templateTree = await this.getTemplate();
+
         // Prefer 'context' over deprecated 'imports'
         const contextStatements = this.options.context || this.options.imports || [];
+
+        // Apply template with value substitution using TemplateEngine
+        // Note: TemplateEngine.applyTemplate will call getTemplateTree again,
+        // but that's okay because it hits the templateCache which is fast
         return TemplateEngine.applyTemplate(
             this.templateParts,
             this.parameters,

package/src/javascript/templating/types.ts

@@ -15,7 +15,7 @@
  */
 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";
 
 /**
@@ -100,14 +100,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 +168,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
@@ -279,6 +280,18 @@ export interface PatternOptions {
  */
 export type TemplateParameter = Capture | any | TemplateParam | Tree | Tree[] | string | number | boolean;
 
+/**
+ * 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.
+ */
+export interface Parameter {
+    /**
+     * The value to substitute into the template.
+     */
+    value: any;
+}
+
 /**
  * Configuration options for templates.
  */
@@ -347,18 +360,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;