@openrewrite/rewrite 8.66.1 → 8.66.2

package/src/javascript/templating/utils.ts

@@ -13,13 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {Cursor} from '../..';
 import {J} from '../../java';
 import {JS} from '../index';
-import {JavaScriptParser} from '../parser';
-import {DependencyWorkspace} from '../dependency-workspace';
-import {Marker} from '../../markers';
+import {Marker, Markers} from '../../markers';
 import {randomId} from '../../uuid';
-import {VariadicOptions, Capture, Any} from './types';
+import {ConstraintFunction, VariadicOptions} from './types';
 
 /**
  * Internal storage value type for pattern match captures.
@@ -36,84 +35,86 @@ export type CaptureStorageValue = J | J.RightPadded<J> | J[] | J.RightPadded<J>[
 export const WRAPPERS_MAP_SYMBOL = Symbol('wrappersMap');
 
 /**
- * Cache for compiled templates and patterns.
- * Stores parsed ASTs to avoid expensive re-parsing and dependency resolution.
+ * Shared wrapper function name used by both patterns and templates.
+ * Using the same name allows cache sharing when pattern and template code is identical.
  */
-export class TemplateCache {
-    private cache = new Map<string, JS.CompilationUnit>();
+export const WRAPPER_FUNCTION_NAME = '__WRAPPER__';
 
-    /**
-     * Generates a cache key from template string, captures, and options.
-     */
-    private generateKey(
-        templateString: string,
-        captures: (Capture | Any<any>)[],
-        contextStatements: string[],
-        dependencies: Record<string, string>
-    ): string {
-        // Use the actual template string (with placeholders) as the primary key
-        const templateKey = templateString;
-
-        // Capture names
-        const capturesKey = captures.map(c => c.getName()).join(',');
-
-        // Context statements
-        const contextKey = contextStatements.join(';');
-
-        // Dependencies
-        const depsKey = JSON.stringify(dependencies || {});
+/**
+ * Simple LRU (Least Recently Used) cache implementation using Map's insertion order.
+ * JavaScript Map maintains insertion order, so the first entry is the oldest.
+ *
+ * Used by both Pattern and Template caching to provide bounded memory usage.
+ */
+export class LRUCache<K, V> {
+    private cache = new Map<K, V>();
 
-        return `${templateKey}::${capturesKey}::${contextKey}::${depsKey}`;
+    constructor(private maxSize: number) {
     }
 
-    /**
-     * Gets a cached compilation unit or creates and caches a new one.
-     */
-    async getOrParse(
-        templateString: string,
-        captures: (Capture | Any<any>)[],
-        contextStatements: string[],
-        dependencies: Record<string, string>
-    ): Promise<JS.CompilationUnit> {
-        const key = this.generateKey(templateString, captures, contextStatements, 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: string | undefined;
-        if (dependencies && Object.keys(dependencies).length > 0) {
-            workspaceDir = await DependencyWorkspace.getOrCreateWorkspace(dependencies);
+    get(key: K): V | undefined {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
         }
+        return value;
+    }
 
-        // Prepend context statements for type attribution context
-        const fullTemplateString = contextStatements.length > 0
-            ? contextStatements.join('\n') + '\n' + templateString
-            : templateString;
+    set(key: K, value: V): void {
+        // Remove if exists (to update position)
+        this.cache.delete(key);
 
-        // Parse and cache (workspace only needed during parsing)
-        const parser = new JavaScriptParser({relativeTo: workspaceDir});
-        const parseGenerator = parser.parse({text: fullTemplateString, sourcePath: 'template.ts'});
-        cu = (await parseGenerator.next()).value as JS.CompilationUnit;
+        // Add to end
+        this.cache.set(key, value);
 
-        this.cache.set(key, cu);
-        return cu;
+        // Evict oldest if over capacity
+        if (this.cache.size > this.maxSize) {
+            const iterator = this.cache.keys();
+            const firstEntry = iterator.next();
+            if (!firstEntry.done) {
+                this.cache.delete(firstEntry.value);
+            }
+        }
     }
 
-    /**
-     * Clears the cache.
-     */
     clear(): void {
         this.cache.clear();
     }
 }
 
-// Global cache instance
-export const templateCache = new TemplateCache();
+/**
+ * Shared global LRU cache for both pattern and template ASTs.
+ * When pattern and template code is identical, they share the same cached AST.
+ * This mirrors JavaTemplate's unified approach in the Java implementation.
+ * Bounded to 100 entries using LRU eviction.
+ */
+export const globalAstCache = new LRUCache<string, J>(100);
+
+/**
+ * Generates a cache key for template/pattern processing.
+ * Used by both Pattern and Template for consistent cache key generation.
+ *
+ * @param templateParts The template string parts
+ * @param itemsKey String representing the captures/parameters (comma-separated)
+ * @param contextStatements Context declarations
+ * @param dependencies NPM dependencies
+ * @returns A cache key string
+ */
+export function generateCacheKey(
+    templateParts: string[] | TemplateStringsArray,
+    itemsKey: string,
+    contextStatements: string[],
+    dependencies: Record<string, string>
+): string {
+    return [
+        Array.from(templateParts).join('|'),
+        itemsKey,
+        contextStatements.join(';'),
+        JSON.stringify(dependencies)
+    ].join('::');
+}
 
 /**
  * Marker that stores capture metadata on pattern AST nodes.
@@ -125,7 +126,8 @@ export class CaptureMarker implements Marker {
 
     constructor(
         public readonly captureName: string,
-        public readonly variadicOptions?: VariadicOptions
+        public readonly variadicOptions?: VariadicOptions,
+        public readonly constraint?: ConstraintFunction<any>
     ) {
     }
 }
@@ -154,30 +156,13 @@ export class PlaceholderUtils {
         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: J): string | undefined {
-        // Check for CaptureMarker
-        for (const marker of node.markers.markers) {
-            if (marker instanceof CaptureMarker) {
-                return marker.captureName;
-            }
-        }
-
-        return undefined;
-    }
-
     /**
      * Gets the CaptureMarker from a node, if present.
      *
      * @param node The node to check
      * @returns The CaptureMarker or undefined
      */
-    static getCaptureMarker(node: J): CaptureMarker | undefined {
+    static getCaptureMarker(node: { markers: Markers }): CaptureMarker | undefined {
         for (const marker of node.markers.markers) {
             if (marker instanceof CaptureMarker) {
                 return marker;
@@ -235,7 +220,7 @@ export class PlaceholderUtils {
      * @param node The node to check
      * @returns true if the node has a variadic CaptureMarker, false otherwise
      */
-    static isVariadicCapture(node: J): boolean {
+    static isVariadicCapture(node: { markers: Markers }): boolean {
         for (const marker of node.markers.markers) {
             if (marker instanceof CaptureMarker && marker.variadicOptions) {
                 return true;
@@ -250,7 +235,7 @@ export class PlaceholderUtils {
      * @param node The node to extract variadic options from
      * @returns The VariadicOptions, or undefined if not a variadic capture
      */
-    static getVariadicOptions(node: J): VariadicOptions | undefined {
+    static getVariadicOptions(node: { markers: Markers }): VariadicOptions | undefined {
         for (const marker of node.markers.markers) {
             if (marker instanceof CaptureMarker) {
                 return marker.variadicOptions;
@@ -260,25 +245,54 @@ export class PlaceholderUtils {
     }
 
     /**
-     * Checks if a statement is an ExpressionStatement wrapping a capture identifier.
-     * When a capture placeholder appears in statement position, the parser wraps it as
-     * an ExpressionStatement. This method unwraps it to get the identifier.
+     * Extracts the relevant AST node from a wrapper function.
+     * Used by both pattern and template processors to intelligently extract
+     * code from `function __WRAPPER__() { code }` wrappers.
      *
-     * @param stmt The statement to check
-     * @returns The unwrapped capture identifier, or the original statement if not wrapped
+     * @param lastStatement The last statement from the compilation unit
+     * @param contextName Context name for error messages (e.g., 'Pattern', 'Template')
+     * @returns The extracted AST node
      */
-    static unwrapStatementCapture(stmt: J): J {
-        // Check if it's an ExpressionStatement containing a capture identifier
-        if (stmt.kind === JS.Kind.ExpressionStatement) {
-            const exprStmt = stmt as JS.ExpressionStatement;
-            if (exprStmt.expression?.kind === J.Kind.Identifier) {
-                const identifier = exprStmt.expression as J.Identifier;
-                // Check if this is a capture placeholder
-                if (identifier.simpleName?.startsWith(this.CAPTURE_PREFIX)) {
-                    return identifier;
+    static extractFromWrapper(lastStatement: J, contextName: string): J {
+        let extracted: J;
+
+        // Since we always wrap in function __WRAPPER__() { code }, look for it
+        if (lastStatement.kind === J.Kind.MethodDeclaration) {
+            const method = lastStatement as J.MethodDeclaration;
+            if (method.name?.simpleName === WRAPPER_FUNCTION_NAME && method.body) {
+                const body = method.body;
+
+                // Intelligently extract based on what's in the function body
+                if (body.statements.length === 0) {
+                    throw new Error(`${contextName} function body is empty`);
+                } else if (body.statements.length === 1) {
+                    const stmt = body.statements[0].element;
+
+                    // Single expression statement → extract the expression
+                    if (stmt.kind === JS.Kind.ExpressionStatement) {
+                        extracted = (stmt as JS.ExpressionStatement).expression;
+                    }
+                    // Single block statement → keep the block
+                    else if (stmt.kind === J.Kind.Block) {
+                        extracted = stmt;
+                    }
+                    // Other single statement → keep it
+                    else {
+                        extracted = stmt;
+                    }
+                } else {
+                    // Multiple statements → keep the block
+                    extracted = body;
                 }
+            } else {
+                // Not our wrapper function
+                extracted = lastStatement;
             }
+        } else {
+            // Shouldn't happen with our wrapping strategy, but handle it
+            extracted = lastStatement;
         }
-        return stmt;
+
+        return extracted;
     }
 }

package/src/javascript/type-mapping.ts

@@ -402,19 +402,28 @@ export class JavaScriptTypeMapping {
                     // If getAliasedSymbol returns something different, it's an import
                     if (aliasedSymbol && aliasedSymbol !== symbol) {
                         // This is definitely an imported symbol
-                        // Now find the import declaration to get the module specifier
-                        if (symbol.declarations && symbol.declarations.length > 0) {
-                            let importNode: ts.Node = symbol.declarations[0];
+                        const aliasedParentSymbol = (aliasedSymbol as any).parent as ts.Symbol | undefined;
 
-                            // Traverse up to find the ImportDeclaration
-                            while (importNode && !ts.isImportDeclaration(importNode)) {
-                                importNode = importNode.parent;
-                            }
+                        if (aliasedParentSymbol && aliasedParentSymbol.declarations?.[0] &&
+                            ts.isModuleDeclaration(aliasedParentSymbol.declarations[0]) &&
+                            ts.isIdentifier(aliasedParentSymbol.declarations[0].name)) {
+                            // For namespace imports, use the namespace symbol's `name` as the module specifier (e.g. `React` instead of `react`)
+                            moduleSpecifier = aliasedParentSymbol.name;
+                        } else {
+                            // Now find the import declaration to get the module specifier
+                            if (symbol.declarations && symbol.declarations.length > 0) {
+                                let importNode: ts.Node = symbol.declarations[0];
 
-                            if (importNode && ts.isImportDeclaration(importNode)) {
-                                const importDeclNode = importNode as ts.ImportDeclaration;
-                                if (ts.isStringLiteral(importDeclNode.moduleSpecifier)) {
-                                    moduleSpecifier = importDeclNode.moduleSpecifier.text;
+                                // Traverse up to find the ImportDeclaration
+                                while (importNode && !ts.isImportDeclaration(importNode)) {
+                                    importNode = importNode.parent;
+                                }
+
+                                if (importNode && ts.isImportDeclaration(importNode)) {
+                                    const importDeclNode = importNode as ts.ImportDeclaration;
+                                    if (ts.isStringLiteral(importDeclNode.moduleSpecifier)) {
+                                        moduleSpecifier = importDeclNode.moduleSpecifier.text;
+                                    }
                                 }
                             }
                         }

package/src/json/rpc.ts

@@ -158,7 +158,7 @@ class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
     }
 
     public async visitSpace(space: Json.Space, q: RpcReceiveQueue): Promise<Json.Space> {
-        return produceAsync<Json.Space>(space, async draft => {
+        return (await produceAsync<Json.Space>(space, async draft => {
             draft.comments = await q.receiveListDefined(space.comments, async c => {
                 return await produceAsync(c, async draft => {
                     draft.multiline = await q.receive(c.multiline);
@@ -168,7 +168,7 @@ class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
                 })
             });
             draft.whitespace = await q.receive(space.whitespace);
-        });
+        }))!;
     }
 
     public async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: RpcReceiveQueue): Promise<Json.RightPadded<T> | undefined> {

package/src/recipe/order-imports.ts

@@ -63,7 +63,7 @@ export class OrderImports extends Recipe {
                 const cuWithImportsSorted = await produceAsync(cu, async draft => {
                     draft.statements = [...sortedImports, ...restStatements];
                 });
-                return produce(cuWithImportsSorted, draft => {
+                return produce(cuWithImportsSorted!, draft => {
                     for (let i = 0; i < importCount; i++) {
                        draft.statements[i].element.prefix.whitespace = i > 0 ? "\n" : "";
                     }

package/src/test/rewrite-test.ts

@@ -175,7 +175,7 @@ export class RecipeSpec {
             (spec.after as (actual: string) => string)(actualAfter) : spec.after as string;
         expect(actualAfter).toEqual(afterSource);
         if (spec.afterRecipe) {
-            await spec.afterRecipe(actualAfter);
+            await spec.afterRecipe(after);
         }
     }
 
@@ -279,9 +279,14 @@ function dedent(s: string): string {
     const str = start > 0 || end < s.length ? s.slice(start, end) : s;
     const lines = str.split('\n');
 
-    // Find minimum indentation (avoid regex for performance)
+    // If we removed a leading newline, consider all lines for minIndent
+    // Otherwise, skip the first line (it's on the same line as the opening quote)
+    const startLine = start > 0 ? 0 : 1;
+
+    // Find minimum indentation
     let minIndent = Infinity;
-    for (const line of lines) {
+    for (let i = startLine; i < lines.length; i++) {
+        const line = lines[i];
         let indent = 0;
         for (let j = 0; j < line.length; j++) {
             const ch = line.charCodeAt(j);
@@ -297,12 +302,12 @@ function dedent(s: string): string {
 
     // If all lines are empty or no indentation
     if (minIndent === Infinity || minIndent === 0) {
-        return lines.map(line => line.trim() || '').join('\n');
+        return lines.join('\n');
     }
 
-    // Remove common indentation from each line
-    return lines.map(line =>
-        line.length >= minIndent ? line.slice(minIndent) : ''
+    // Remove common indentation from lines (skip first line only if we didn't remove leading newline)
+    return lines.map((line, i) =>
+        (i === 0 && startLine === 1) ? line : (line.length >= minIndent ? line.slice(minIndent) : '')
     ).join('\n');
 }
 

package/src/visitor.ts

@@ -15,7 +15,7 @@
  */
 import {emptyMarkers, Marker, Markers} from "./markers";
 import {Cursor, isSourceFile, rootCursor, SourceFile, Tree} from "./tree";
-import {createDraft, Draft, finishDraft, Objectish} from "immer";
+import {createDraft, Draft, finishDraft, nothing, Objectish} from "immer";
 import {mapAsync} from "./util";
 
 /* Not exported beyond the internal immer module */
@@ -23,15 +23,23 @@ export type ValidImmerRecipeReturnType<State> =
     | State
     | void
     | undefined
+    | typeof nothing
 
 export async function produceAsync<Base extends Objectish>(
     before: Promise<Base> | Base,
     recipe: (draft: Draft<Base>) => ValidImmerRecipeReturnType<Draft<Base>> |
         PromiseLike<ValidImmerRecipeReturnType<Draft<Base>>>
-): Promise<Base> {
+): Promise<Base | undefined> {
     const b: Base = await before;
     const draft = createDraft(b);
-    await recipe(draft);
+    const result = await recipe(draft);
+
+    // If recipe explicitly returned Immer's nothing, return undefined
+    if (result === nothing) {
+        return undefined;
+    }
+
+    // Otherwise, return the finished draft (void/undefined means use draft)
     return finishDraft(draft) as Base;
 }
 
@@ -128,9 +136,9 @@ export abstract class TreeVisitor<T extends Tree, P> {
         } else if ((markers.markers?.length || 0) === 0) {
             return markers;
         }
-        return produceAsync<Markers>(markers, async (draft) => {
+        return (await produceAsync<Markers>(markers, async (draft) => {
             draft.markers = await mapAsync(markers.markers, m => this.visitMarker(m, p))
-        });
+        }))!;
     }
 
     protected async visitMarker<M extends Marker>(marker: M, p: P): Promise<M> {
@@ -143,7 +151,7 @@ export abstract class TreeVisitor<T extends Tree, P> {
         recipe?:
             ((draft: Draft<T>) => ValidImmerRecipeReturnType<Draft<T>>) |
             ((draft: Draft<T>) => Promise<ValidImmerRecipeReturnType<Draft<T>>>)
-    ): Promise<T> {
+    ): Promise<T | undefined> {
         return produceAsync(before, async draft => {
             draft.markers = await this.visitMarkers(before.markers, p);
             if (recipe) {