@openrewrite/rewrite 8.63.3 → 8.63.4

package/dist/javascript/templating.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Template = exports.MatchResult = exports.Pattern = void 0;
+exports.Template = exports.MatchResult = exports.Pattern = exports._ = void 0;
 exports.capture = capture;
 exports.pattern = pattern;
 exports.template = template;
@@ -36,6 +36,79 @@ const __1 = require("..");
 const java_1 = require("../java");
 const immer_1 = require("immer");
 const comparator_1 = require("./comparator");
+const dependency_workspace_1 = require("./dependency-workspace");
+const uuid_1 = require("../uuid");
+/**
+ * Cache for compiled templates and patterns.
+ * Stores parsed ASTs to avoid expensive re-parsing and dependency resolution.
+ */
+class TemplateCache {
+    constructor() {
+        this.cache = new Map();
+    }
+    /**
+     * Generates a cache key from template string, captures, and options.
+     */
+    generateKey(templateString, captures, imports, dependencies) {
+        // Use the actual template string (with placeholders) as the primary key
+        const templateKey = templateString;
+        // Capture names
+        const capturesKey = captures.map(c => c.name).join(',');
+        // Imports
+        const importsKey = imports.join(';');
+        // Dependencies
+        const depsKey = JSON.stringify(dependencies || {});
+        return `${templateKey}::${capturesKey}::${importsKey}::${depsKey}`;
+    }
+    /**
+     * Gets a cached compilation unit or creates and caches a new one.
+     */
+    getOrParse(templateString, captures, imports, dependencies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.generateKey(templateString, captures, imports, dependencies);
+            let cu = this.cache.get(key);
+            if (cu) {
+                return cu;
+            }
+            // Create workspace if dependencies are provided
+            // DependencyWorkspace has its own cache, so multiple templates with
+            // the same dependencies will automatically share the same workspace
+            let workspaceDir;
+            if (dependencies && Object.keys(dependencies).length > 0) {
+                workspaceDir = yield dependency_workspace_1.DependencyWorkspace.getOrCreateWorkspace(dependencies);
+            }
+            // Prepend imports for type attribution context
+            const fullTemplateString = imports.length > 0
+                ? imports.join('\n') + '\n' + templateString
+                : templateString;
+            // Parse and cache (workspace only needed during parsing)
+            const parser = new parser_1.JavaScriptParser({ relativeTo: workspaceDir });
+            const parseGenerator = parser.parse({ text: fullTemplateString, sourcePath: 'template.ts' });
+            cu = (yield parseGenerator.next()).value;
+            this.cache.set(key, cu);
+            return cu;
+        });
+    }
+    /**
+     * Clears the cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+}
+// Global cache instance
+const templateCache = new TemplateCache();
+/**
+ * Marker that stores capture metadata on pattern AST nodes.
+ * This avoids the need to parse capture names from identifiers during matching.
+ */
+class CaptureMarker {
+    constructor(captureName) {
+        this.captureName = captureName;
+        this.kind = 'org.openrewrite.javascript.CaptureMarker';
+        this.id = (0, uuid_1.randomId)();
+    }
+}
 class CaptureImpl {
     constructor(name) {
         this.name = name;
@@ -44,26 +117,52 @@ class CaptureImpl {
 /**
  * Creates a capture specification for use in template patterns.
  *
+ * @param name Optional name for the capture. If not provided, an auto-generated name is used.
  * @returns A Capture object
  *
  * @example
- * // Multiple captures
+ * // Named inline captures
+ * const pattern = pattern`${capture('left')} + ${capture('right')}`;
+ *
+ * // Unnamed captures
  * const {left, right} = {left: capture(), right: capture()};
  * const pattern = pattern`${left} + ${right}`;
  *
  * // Repeated patterns using the same capture
- * const expr = capture();
+ * const expr = capture('expr');
  * const redundantOr = pattern`${expr} || ${expr}`;
  */
-function capture() {
+function capture(name) {
+    if (name) {
+        return new CaptureImpl(name);
+    }
     return new CaptureImpl(`unnamed_${capture.nextUnnamedId++}`);
 }
 // Static counter for generating unique IDs for unnamed captures
 capture.nextUnnamedId = 1;
+/**
+ * Concise alias for `capture`. Works well for inline captures in patterns and templates.
+ *
+ * @param name Optional name for the capture. If not provided, an auto-generated name is used.
+ * @returns A Capture object
+ *
+ * @example
+ * // Inline captures with _ alias
+ * pattern`isDate(${_('dateArg')})`
+ * template`${_('dateArg')} instanceof Date`
+ */
+exports._ = capture;
 /**
  * Represents a pattern that can be matched against AST nodes.
  */
 class Pattern {
+    /**
+     * Gets the configuration options for this pattern.
+     * @readonly
+     */
+    get options() {
+        return this._options;
+    }
     /**
      * Creates a new pattern from template parts and captures.
      *
@@ -73,6 +172,24 @@ class Pattern {
     constructor(templateParts, captures) {
         this.templateParts = templateParts;
         this.captures = captures;
+        this._options = {};
+    }
+    /**
+     * Configures this pattern with additional options.
+     *
+     * @param options Configuration options
+     * @returns This pattern for method chaining
+     *
+     * @example
+     * pattern`isDate(${capture('date')})`
+     *     .configure({
+     *         imports: ['import { isDate } from "util"'],
+     *         dependencies: { 'util': '^1.0.0' }
+     *     })
+     */
+    configure(options) {
+        this._options = Object.assign(Object.assign({}, this._options), options);
+        return this;
     }
     /**
      * Creates a matcher for this pattern against a specific AST node.
@@ -99,6 +216,142 @@ class MatchResult {
     }
 }
 exports.MatchResult = MatchResult;
+/**
+ * A comparator visitor that checks semantic equality including type attribution.
+ * This ensures that patterns only match code with compatible types, not just
+ * structurally similar code.
+ */
+class JavaScriptTemplateSemanticallyEqualVisitor extends comparator_1.JavaScriptComparatorVisitor {
+    /**
+     * Checks if two types are semantically equal.
+     * For method types, this checks that the declaring type and method name match.
+     */
+    isOfType(target, source) {
+        if (!target || !source) {
+            return target === source;
+        }
+        if (target.kind !== source.kind) {
+            return false;
+        }
+        // For method types, check declaring type
+        // Note: We don't check the name field because it might not be fully resolved in patterns
+        // The method invocation visitor already checks that simple names match
+        if (target.kind === java_1.Type.Kind.Method && source.kind === java_1.Type.Kind.Method) {
+            const targetMethod = target;
+            const sourceMethod = source;
+            // Only check that declaring types match
+            return this.isOfType(targetMethod.declaringType, sourceMethod.declaringType);
+        }
+        // For fully qualified types, check the fully qualified name
+        if (java_1.Type.isFullyQualified(target) && java_1.Type.isFullyQualified(source)) {
+            return java_1.Type.FullyQualified.getFullyQualifiedName(target) ===
+                java_1.Type.FullyQualified.getFullyQualifiedName(source);
+        }
+        // Default: types are equal if they're the same kind
+        return true;
+    }
+    /**
+     * Override method invocation comparison to include type attribution checking.
+     * When types match semantically, we allow matching even if one has a receiver
+     * and the other doesn't (e.g., `isDate(x)` vs `util.isDate(x)`).
+     */
+    visitMethodInvocation(method, other) {
+        const _super = Object.create(null, {
+            visitMethodInvocation: { get: () => super.visitMethodInvocation }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (other.kind !== java_1.J.Kind.MethodInvocation) {
+                return method;
+            }
+            const otherMethod = other;
+            // Check basic structural equality first
+            if (method.name.simpleName !== otherMethod.name.simpleName ||
+                method.arguments.elements.length !== otherMethod.arguments.elements.length) {
+                this.abort();
+                return method;
+            }
+            // Check type attribution
+            // Both must have method types for semantic equality
+            if (!method.methodType || !otherMethod.methodType) {
+                // If template has type but target doesn't, they don't match
+                if (method.methodType || otherMethod.methodType) {
+                    this.abort();
+                    return method;
+                }
+                // If neither has type, fall through to structural comparison
+                return _super.visitMethodInvocation.call(this, method, other);
+            }
+            // Both have types - check they match semantically
+            const typesMatch = this.isOfType(method.methodType, otherMethod.methodType);
+            if (!typesMatch) {
+                // Types don't match - abort comparison
+                this.abort();
+                return method;
+            }
+            // Types match! Now we can ignore receiver differences and just compare arguments.
+            // This allows pattern `isDate(x)` to match both `isDate(x)` and `util.isDate(x)`
+            // when they have the same type attribution.
+            // Compare type parameters
+            if ((method.typeParameters === undefined) !== (otherMethod.typeParameters === undefined)) {
+                this.abort();
+                return method;
+            }
+            if (method.typeParameters && otherMethod.typeParameters) {
+                if (method.typeParameters.elements.length !== otherMethod.typeParameters.elements.length) {
+                    this.abort();
+                    return method;
+                }
+                for (let i = 0; i < method.typeParameters.elements.length; i++) {
+                    yield this.visit(method.typeParameters.elements[i].element, otherMethod.typeParameters.elements[i].element);
+                    if (!this.match)
+                        return method;
+                }
+            }
+            // Compare name (already checked simpleName above, but visit for markers/prefix)
+            yield this.visit(method.name, otherMethod.name);
+            if (!this.match)
+                return method;
+            // Compare arguments
+            for (let i = 0; i < method.arguments.elements.length; i++) {
+                yield this.visit(method.arguments.elements[i].element, otherMethod.arguments.elements[i].element);
+                if (!this.match)
+                    return method;
+            }
+            return method;
+        });
+    }
+    /**
+     * Override identifier comparison to include type checking for field access.
+     */
+    visitIdentifier(identifier, other) {
+        const _super = Object.create(null, {
+            visitIdentifier: { get: () => super.visitIdentifier }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (other.kind !== java_1.J.Kind.Identifier) {
+                return identifier;
+            }
+            const otherIdentifier = other;
+            // Check name matches
+            if (identifier.simpleName !== otherIdentifier.simpleName) {
+                return identifier;
+            }
+            // For identifiers with field types, check type attribution
+            if (identifier.fieldType && otherIdentifier.fieldType) {
+                if (!this.isOfType(identifier.fieldType, otherIdentifier.fieldType)) {
+                    this.abort();
+                    return identifier;
+                }
+            }
+            else if (identifier.fieldType || otherIdentifier.fieldType) {
+                // If only one has a type, they don't match
+                this.abort();
+                return identifier;
+            }
+            return _super.visitIdentifier.call(this, identifier, other);
+        });
+    }
+}
 /**
  * Matcher for checking if a pattern matches an AST node and extracting captured nodes.
  */
@@ -122,8 +375,8 @@ class Matcher {
     matches() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.patternAst) {
-                this.templateProcessor = new TemplateProcessor(this.pattern.templateParts, this.pattern.captures);
-                this.patternAst = yield this.templateProcessor.toAstPattern();
+                const templateProcessor = new TemplateProcessor(this.pattern.templateParts, this.pattern.captures, this.pattern.options.imports || [], this.pattern.options.dependencies || {});
+                this.patternAst = yield templateProcessor.toAstPattern();
             }
             return this.matchNode(this.patternAst, this.ast);
         });
@@ -154,7 +407,7 @@ class Matcher {
                 return false;
             }
             const matcher = this;
-            return yield ((new class extends comparator_1.JavaScriptComparatorVisitor {
+            return yield ((new class extends JavaScriptTemplateSemanticallyEqualVisitor {
                 hasSameKind(j, other) {
                     return super.hasSameKind(j, other) || j.kind == java_1.J.Kind.Identifier && this.matchesParameter(j, other);
                 }
@@ -167,8 +420,7 @@ class Matcher {
                     });
                 }
                 matchesParameter(identifier, other) {
-                    return PlaceholderUtils.isCapture(identifier) &&
-                        matcher.handleCapture(identifier, other);
+                    return PlaceholderUtils.isCapture(identifier) && matcher.handleCapture(identifier, other);
                 }
             }).compare(pattern, target));
         });
@@ -181,13 +433,12 @@ class Matcher {
      * @returns true if the capture is successful, false otherwise
      */
     handleCapture(pattern, target) {
-        const id = pattern;
-        const captureInfo = PlaceholderUtils.parseCapture(id.simpleName);
-        if (!captureInfo) {
+        const captureName = PlaceholderUtils.getCaptureName(pattern);
+        if (!captureName) {
             return false;
         }
         // Store the binding
-        this.bindings.set(captureInfo.name, target);
+        this.bindings.set(captureName, target);
         return true;
     }
 }
@@ -243,6 +494,24 @@ class Template {
     constructor(templateParts, parameters) {
         this.templateParts = templateParts;
         this.parameters = parameters;
+        this.options = {};
+    }
+    /**
+     * Configures this template with additional options.
+     *
+     * @param options Configuration options
+     * @returns This template for method chaining
+     *
+     * @example
+     * template`isDate(${capture('date')})`
+     *     .configure({
+     *         imports: ['import { isDate } from "util"'],
+     *         dependencies: { 'util': '^1.0.0' }
+     *     })
+     */
+    configure(options) {
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        return this;
     }
     /**
      * Applies this template and returns the resulting tree.
@@ -257,7 +526,7 @@ class Template {
             return TemplateEngine.applyTemplate(this.templateParts, this.parameters, cursor, {
                 tree,
                 mode: JavaCoordinates.Mode.Replace
-            }, values);
+            }, values, this.options.imports || [], this.options.dependencies || {});
         });
     }
 }
@@ -283,34 +552,43 @@ class TemplateEngine {
      * @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 imports Import statements to prepend for type attribution
+     * @param dependencies NPM dependencies for type attribution
      * @returns A Promise resolving to the generated AST node
      */
     static applyTemplate(templateParts_1, parameters_1, cursor_1, coordinates_1) {
-        return __awaiter(this, arguments, void 0, function* (templateParts, parameters, cursor, coordinates, values = new Map()) {
+        return __awaiter(this, arguments, void 0, function* (templateParts, parameters, cursor, coordinates, values = new Map(), imports = [], dependencies = {}) {
             // 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;
             }
-            // Parse the template string into an AST
-            const parser = new parser_1.JavaScriptParser();
-            const parseGenerator = parser.parse({ text: templateString, sourcePath: 'template.ts' });
-            const cu = (yield parseGenerator.next()).value;
+            // Use cache to get or parse the compilation unit
+            // For templates, we don't have captures, so use empty array
+            const cu = yield templateCache.getOrParse(templateString, [], // templates don't have captures in the cache key
+            imports, dependencies);
             // Check if there are any statements
             if (!cu.statements || cu.statements.length === 0) {
                 return undefined;
             }
+            // Skip import statements to get to the actual template code
+            const templateStatementIndex = imports.length;
+            if (templateStatementIndex >= cu.statements.length) {
+                return undefined;
+            }
             // Extract the relevant part of the AST
-            const firstStatement = cu.statements[0].element;
-            const ast = firstStatement.kind === _1.JS.Kind.ExpressionStatement ?
+            const firstStatement = cu.statements[templateStatementIndex].element;
+            let extracted = firstStatement.kind === _1.JS.Kind.ExpressionStatement ?
                 firstStatement.expression :
                 firstStatement;
+            // Create a copy to avoid sharing cached AST instances
+            const ast = (0, immer_1.produce)(extracted, draft => { });
             // Create substitutions map for placeholders
             const substitutions = new Map();
             for (let i = 0; i < parameters.length; i++) {
                 const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
-                substitutions.set(placeholder, typeof parameters[i].value === 'string' ? { value: values.get(parameters[i].value) || parameters[i].value } : parameters[i]);
+                substitutions.set(placeholder, parameters[i]);
             }
             // Unsubstitute placeholders with actual parameter values and match results
             const visitor = new PlaceholderReplacementVisitor(substitutions, values);
@@ -331,12 +609,15 @@ class TemplateEngine {
         for (let i = 0; i < templateParts.length; i++) {
             result += templateParts[i];
             if (i < parameters.length) {
-                if (parameters[i].value instanceof CaptureImpl || typeof parameters[i].value === 'string' || (0, __1.isTree)(parameters[i].value)) {
+                const param = parameters[i].value;
+                // Use a placeholder for Captures and Tree nodes
+                // Inline everything else (strings, numbers, booleans) directly
+                if (param instanceof CaptureImpl || (0, __1.isTree)(param)) {
                     const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
                     result += placeholder;
                 }
                 else {
-                    result += parameters[i].value;
+                    result += param;
                 }
             }
         }
@@ -355,12 +636,29 @@ class PlaceholderUtils {
      * @returns true if the node is a capture placeholder, false otherwise
      */
     static isCapture(node) {
-        if (node.kind === java_1.J.Kind.Identifier) {
-            const id = node;
-            return id.simpleName.startsWith(this.CAPTURE_PREFIX);
+        // Check for CaptureMarker first (efficient)
+        for (const marker of node.markers.markers) {
+            if (marker instanceof CaptureMarker) {
+                return true;
+            }
         }
         return false;
     }
+    /**
+     * Gets the capture name from a node with a CaptureMarker.
+     *
+     * @param node The node to extract capture name from
+     * @returns The capture name, or null if not a capture
+     */
+    static getCaptureName(node) {
+        // Check for CaptureMarker
+        for (const marker of node.markers.markers) {
+            if (marker instanceof CaptureMarker) {
+                return marker.captureName;
+            }
+        }
+        return undefined;
+    }
     /**
      * Parses a capture placeholder to extract name and type constraint.
      *
@@ -582,10 +880,14 @@ class TemplateProcessor {
      *
      * @param templateParts The string parts of the template
      * @param captures The captures between the string parts
+     * @param imports Import statements to prepend for type attribution
+     * @param dependencies NPM dependencies for type attribution
      */
-    constructor(templateParts, captures) {
+    constructor(templateParts, captures, imports = [], dependencies = {}) {
         this.templateParts = templateParts;
         this.captures = captures;
+        this.imports = imports;
+        this.dependencies = dependencies;
     }
     /**
      * Converts the template to an AST pattern.
@@ -596,10 +898,8 @@ class TemplateProcessor {
         return __awaiter(this, void 0, void 0, function* () {
             // Combine template parts and placeholders
             const templateString = this.buildTemplateString();
-            // Parse template string to AST
-            const parser = new parser_1.JavaScriptParser();
-            const parseGenerator = parser.parse({ text: templateString, sourcePath: 'template.ts' });
-            const cu = (yield parseGenerator.next()).value;
+            // Use cache to get or parse the compilation unit
+            const cu = yield templateCache.getOrParse(templateString, this.captures, this.imports, this.dependencies);
             // Extract the relevant part of the AST
             return this.extractPatternFromAst(cu);
         });
@@ -627,14 +927,75 @@ class TemplateProcessor {
      * @returns The extracted pattern
      */
     extractPatternFromAst(cu) {
+        // Skip import statements to get to the actual pattern code
+        const patternStatementIndex = this.imports.length;
         // Extract the relevant part of the AST based on the template content
-        const firstStatement = cu.statements[0].element;
+        const firstStatement = cu.statements[patternStatementIndex].element;
+        let extracted;
         // If the first statement is an expression statement, extract the expression
         if (firstStatement.kind === _1.JS.Kind.ExpressionStatement) {
-            return firstStatement.expression;
+            extracted = firstStatement.expression;
+        }
+        else {
+            // Otherwise, return the statement itself
+            extracted = firstStatement;
+        }
+        // Attach CaptureMarkers to capture identifiers
+        return this.attachCaptureMarkers(extracted);
+    }
+    /**
+     * Attaches CaptureMarkers to capture identifiers in the AST.
+     * This allows efficient capture detection without string parsing.
+     *
+     * @param ast The AST to process
+     * @returns The AST with CaptureMarkers attached
+     */
+    attachCaptureMarkers(ast) {
+        const visited = new Set();
+        return (0, immer_1.produce)(ast, draft => {
+            this.visitAndAttachMarkers(draft, visited);
+        });
+    }
+    /**
+     * Recursively visits AST nodes and attaches CaptureMarkers to capture identifiers.
+     *
+     * @param node The node to visit
+     * @param visited Set of already visited nodes to avoid cycles
+     */
+    visitAndAttachMarkers(node, visited) {
+        var _a;
+        if (!node || typeof node !== 'object' || visited.has(node)) {
+            return;
+        }
+        // Mark as visited to avoid cycles
+        visited.add(node);
+        // If this is an identifier that looks like a capture, attach a marker
+        if (node.kind === java_1.J.Kind.Identifier && ((_a = node.simpleName) === null || _a === void 0 ? void 0 : _a.startsWith(PlaceholderUtils.CAPTURE_PREFIX))) {
+            const captureInfo = PlaceholderUtils.parseCapture(node.simpleName);
+            if (captureInfo) {
+                // Initialize markers if needed
+                if (!node.markers) {
+                    node.markers = { kind: 'org.openrewrite.marker.Markers', id: (0, uuid_1.randomId)(), markers: [] };
+                }
+                if (!node.markers.markers) {
+                    node.markers.markers = [];
+                }
+                // Add CaptureMarker
+                node.markers.markers.push(new CaptureMarker(captureInfo.name));
+            }
+        }
+        // Recursively visit all properties
+        for (const key in node) {
+            if (node.hasOwnProperty(key)) {
+                const value = node[key];
+                if (Array.isArray(value)) {
+                    value.forEach(item => this.visitAndAttachMarkers(item, visited));
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    this.visitAndAttachMarkers(value, visited);
+                }
+            }
         }
-        // Otherwise, return the statement itself
-        return firstStatement;
     }
 }
 /**
@@ -669,20 +1030,33 @@ class RewriteRuleImpl {
  *
  * @example
  * // Single pattern
- * const swapOperands = replace<J.Binary>(() => ({
+ * const swapOperands = rewrite(() => ({
  *     before: pattern`${"left"} + ${"right"}`,
  *     after: template`${"right"} + ${"left"}`
  * }));
  *
  * @example
  * // Multiple patterns
- * const normalizeComparisons = replace<J.Binary>(() => ({
+ * const normalizeComparisons = rewrite(() => ({
  *     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();