@openrewrite/rewrite 8.67.0-20251104-132125 → 8.67.0-20251104-141355

package/src/javascript/templating/capture.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {J} from '../../java';
-import {Capture, Any, TemplateParam, CaptureOptions, VariadicOptions} from './types';
+import {J, Type} from '../../java';
+import {Any, Capture, CaptureOptions, TemplateParam, VariadicOptions} from './types';
 
 /**
  * Combines multiple constraints with AND logic.
@@ -70,6 +70,8 @@ export const CAPTURE_VARIADIC_SYMBOL = Symbol('captureVariadic');
 export const CAPTURE_CONSTRAINT_SYMBOL = Symbol('captureConstraint');
 // Symbol to access capturing flag without triggering Proxy
 export const CAPTURE_CAPTURING_SYMBOL = Symbol('captureCapturing');
+// Symbol to access type information without triggering Proxy
+export const CAPTURE_TYPE_SYMBOL = Symbol('captureType');
 
 export class CaptureImpl<T = any> implements Capture<T> {
     public readonly name: string;
@@ -77,6 +79,7 @@ export class CaptureImpl<T = any> implements Capture<T> {
     [CAPTURE_VARIADIC_SYMBOL]: VariadicOptions | undefined;
     [CAPTURE_CONSTRAINT_SYMBOL]: ((node: T) => boolean) | undefined;
     [CAPTURE_CAPTURING_SYMBOL]: boolean;
+    [CAPTURE_TYPE_SYMBOL]: string | Type | undefined;
 
     constructor(name: string, options?: CaptureOptions<T>, capturing: boolean = true) {
         this.name = name;
@@ -99,6 +102,11 @@ export class CaptureImpl<T = any> implements Capture<T> {
         if (options?.constraint) {
             this[CAPTURE_CONSTRAINT_SYMBOL] = options.constraint;
         }
+
+        // Store type if provided
+        if (options?.type) {
+            this[CAPTURE_TYPE_SYMBOL] = options.type;
+        }
     }
 
     getName(): string {
@@ -120,6 +128,10 @@ export class CaptureImpl<T = any> implements Capture<T> {
     isCapturing(): boolean {
         return this[CAPTURE_CAPTURING_SYMBOL];
     }
+
+    getType(): string | Type | undefined {
+        return this[CAPTURE_TYPE_SYMBOL];
+    }
 }
 
 export class TemplateParamImpl<T = any> implements TemplateParam<T> {
@@ -291,6 +303,9 @@ function createCaptureProxy<T>(impl: CaptureImpl<T>): any {
             if (prop === CAPTURE_CAPTURING_SYMBOL) {
                 return target[CAPTURE_CAPTURING_SYMBOL];
             }
+            if (prop === CAPTURE_TYPE_SYMBOL) {
+                return target[CAPTURE_TYPE_SYMBOL];
+            }
 
             // Support using Capture as object key via computed properties {[x]: value}
             if (prop === Symbol.toPrimitive || prop === 'toString' || prop === 'valueOf') {
@@ -298,7 +313,7 @@ function createCaptureProxy<T>(impl: CaptureImpl<T>): any {
             }
 
             // Allow methods to be called directly on the target
-            if (prop === 'getName' || prop === 'isVariadic' || prop === 'getVariadicOptions' || prop === 'getConstraint' || prop === 'isCapturing') {
+            if (prop === 'getName' || prop === 'isVariadic' || prop === 'getVariadicOptions' || prop === 'getConstraint' || prop === 'isCapturing' || prop === 'getType') {
                 return target[prop].bind(target);
             }
 
@@ -335,7 +350,7 @@ function createCaptureProxy<T>(impl: CaptureImpl<T>): any {
 
 // Overload 1: Options object with constraint (no variadic)
 export function capture<T = any>(
-    options: { name?: string; constraint: (node: T) => boolean } & { variadic?: never }
+    options: CaptureOptions<T> & { variadic?: never }
 ): Capture<T> & T;
 
 // Overload 2: Options object with variadic

package/src/javascript/templating/engine.ts

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 import {Cursor, isTree} from '../..';
-import {J} from '../../java';
+import {J, Type} from '../../java';
 import {JS} from '..';
 import {produce} from 'immer';
-import {TemplateCache, PlaceholderUtils} from './utils';
-import {CaptureImpl, TemplateParamImpl, CaptureValue, CAPTURE_NAME_SYMBOL} from './capture';
+import {PlaceholderUtils, TemplateCache} from './utils';
+import {CAPTURE_NAME_SYMBOL, CAPTURE_TYPE_SYMBOL, CaptureImpl, CaptureValue, TemplateParamImpl} from './capture';
 import {PlaceholderReplacementVisitor} from './placeholder-replacement';
 import {JavaCoordinates} from './template';
 
@@ -66,6 +66,9 @@ export class TemplateEngine {
         contextStatements: string[] = [],
         dependencies: Record<string, string> = {}
     ): Promise<J | undefined> {
+        // Generate type preamble for captures/parameters with types
+        const preamble = TemplateEngine.generateTypePreamble(parameters);
+
         // Build the template string with parameter placeholders
         const templateString = TemplateEngine.buildTemplateString(templateParts, parameters);
 
@@ -74,12 +77,17 @@ export class TemplateEngine {
             return undefined;
         }
 
+        // Add preamble to context statements (so they're skipped during extraction)
+        const contextWithPreamble = preamble.length > 0
+            ? [...contextStatements, ...preamble]
+            : contextStatements;
+
         // Use cache to get or parse the compilation unit
         // For templates, we don't have captures, so use empty array
         const cu = await templateCache.getOrParse(
             templateString,
             [], // templates don't have captures in the cache key
-            contextStatements,
+            contextWithPreamble,
             dependencies
         );
 
@@ -88,31 +96,25 @@ export class TemplateEngine {
             throw new Error(`Failed to parse template code (no statements):\n${templateString}`);
         }
 
-        // Skip context statements to get to the actual template code
-        const templateStatementIndex = contextStatements.length;
-        if (templateStatementIndex >= cu.statements.length) {
-            return undefined;
-        }
-
-        // Extract the relevant part of the AST
-        const firstStatement = cu.statements[templateStatementIndex].element;
+        // The template code is always the last statement (after context + preamble)
+        const lastStatement = cu.statements[cu.statements.length - 1].element;
         let extracted: J;
 
         // Check if this is a wrapped template (function __TEMPLATE__() { ... })
-        if (firstStatement.kind === J.Kind.MethodDeclaration) {
-            const func = firstStatement as J.MethodDeclaration;
+        if (lastStatement.kind === J.Kind.MethodDeclaration) {
+            const func = lastStatement as J.MethodDeclaration;
             if (func.name.simpleName === '__TEMPLATE__' && func.body) {
                 // __TEMPLATE__ wrapper indicates the original template was a block.
                 // Always return the block to preserve the block structure.
                 extracted = func.body;
             } else {
                 // Not a __TEMPLATE__ wrapper
-                extracted = firstStatement;
+                extracted = lastStatement;
             }
-        } else if (firstStatement.kind === JS.Kind.ExpressionStatement) {
-            extracted = (firstStatement as JS.ExpressionStatement).expression;
+        } else if (lastStatement.kind === JS.Kind.ExpressionStatement) {
+            extracted = (lastStatement as JS.ExpressionStatement).expression;
         } else {
-            extracted = firstStatement;
+            extracted = lastStatement;
         }
 
         // Create a copy to avoid sharing cached AST instances
@@ -133,6 +135,58 @@ export class TemplateEngine {
         return new TemplateApplier(cursor, coordinates, unsubstitutedAst).apply();
     }
 
+    /**
+     * Generates type preamble declarations for captures/parameters with type annotations.
+     *
+     * @param parameters The parameters
+     * @returns Array of preamble statements
+     */
+    private static generateTypePreamble(parameters: Parameter[]): string[] {
+        const preamble: string[] = [];
+
+        for (let i = 0; i < parameters.length; i++) {
+            const param = parameters[i].value;
+            const placeholder = `${PlaceholderUtils.PLACEHOLDER_PREFIX}${i}__`;
+
+            // Check for Capture (could be a Proxy, so check for symbol property)
+            const isCapture = param instanceof CaptureImpl ||
+                            (param && typeof param === 'object' && param[CAPTURE_NAME_SYMBOL]);
+            const isCaptureValue = param instanceof CaptureValue;
+            const isTreeArray = Array.isArray(param) && param.length > 0 && isTree(param[0]);
+
+            if (isCapture) {
+                const captureType = param[CAPTURE_TYPE_SYMBOL];
+                if (captureType) {
+                    const typeString = typeof captureType === 'string'
+                        ? captureType
+                        : this.typeToString(captureType);
+                    preamble.push(`const ${placeholder}: ${typeString};`);
+                }
+            } else if (isCaptureValue) {
+                // For CaptureValue, check if the root capture has a type
+                const rootCapture = param.rootCapture;
+                if (rootCapture) {
+                    const captureType = (rootCapture as any)[CAPTURE_TYPE_SYMBOL];
+                    if (captureType) {
+                        const typeString = typeof captureType === 'string'
+                            ? captureType
+                            : this.typeToString(captureType);
+                        preamble.push(`const ${placeholder}: ${typeString};`);
+                    }
+                }
+            } else if (isTree(param) && !isTreeArray) {
+                // For J elements, derive type from the element's type property if it exists
+                const jElement = param as J;
+                if ((jElement as any).type) {
+                    const typeString = this.typeToString((jElement as any).type);
+                    preamble.push(`const ${placeholder}: ${typeString};`);
+                }
+            }
+        }
+
+        return preamble;
+    }
+
     /**
      * Builds a template string with parameter placeholders.
      *
@@ -174,6 +228,53 @@ export class TemplateEngine {
 
         return result;
     }
+
+    /**
+     * Converts a Type instance to a TypeScript type string.
+     *
+     * @param type The Type instance
+     * @returns A TypeScript type string
+     */
+    private static 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';
+    }
 }
 
 /**

package/src/javascript/templating/pattern.ts

@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 import {produce} from 'immer';
-import {J} from '../../java';
+import {J, Type} from '../../java';
 import {JS} from '../index';
 import {randomId} from '../../uuid';
-import {Capture, Any, PatternOptions} from './types';
-import {CaptureImpl, CAPTURE_NAME_SYMBOL, CAPTURE_CAPTURING_SYMBOL} from './capture';
+import {Any, Capture, PatternOptions} from './types';
+import {CAPTURE_CAPTURING_SYMBOL, CAPTURE_NAME_SYMBOL, CAPTURE_TYPE_SYMBOL, CaptureImpl} from './capture';
 import {PatternMatchingComparator} from './comparator';
-import {PlaceholderUtils, templateCache, CaptureMarker, CaptureStorageValue, WRAPPERS_MAP_SYMBOL} from './utils';
+import {CaptureMarker, CaptureStorageValue, PlaceholderUtils, templateCache, WRAPPERS_MAP_SYMBOL} from './utils';
 
 /**
  * Builder for creating patterns programmatically.
@@ -514,21 +514,52 @@ class TemplateProcessor {
      * @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,
-            this.contextStatements,
+            contextWithPreamble,
             this.dependencies
         );
 
         // Extract the relevant part of the AST
+        // The pattern code is always the last statement (after context + preamble)
         return 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(`const ${placeholder}: ${typeString};`);
+            }
+        }
+        return preamble;
+    }
+
     /**
      * Builds a template string with placeholders for captures.
      * If the template looks like a block pattern, wraps it in a function.
@@ -561,46 +592,87 @@ class TemplateProcessor {
         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 extractPatternFromAst(cu: JS.CompilationUnit): J {
-        // Skip context statements to get to the actual pattern code
-        const patternStatementIndex = this.contextStatements.length;
-
-        // Check if we have any statements at the pattern index
-        if (!cu.statements || patternStatementIndex >= cu.statements.length) {
-            // If there's no statement at the index, but we have exactly one statement
-            // and it's a block, it might be the pattern itself (e.g., pattern`{ ... }`)
-            if (cu.statements && cu.statements.length === 1 && cu.statements[0].element.kind === J.Kind.Block) {
-                return this.attachCaptureMarkers(cu.statements[0].element);
-            }
-            throw new Error(`No statement found at index ${patternStatementIndex} in compilation unit with ${cu.statements?.length || 0} statements`);
+        // Check if we have any statements
+        if (!cu.statements || cu.statements.length === 0) {
+            throw new Error(`No statements found in compilation unit`);
         }
 
-        // Extract the relevant part of the AST based on the template content
-        const firstStatement = cu.statements[patternStatementIndex].element;
+        // 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 (firstStatement.kind === J.Kind.MethodDeclaration) {
-            const method = firstStatement as J.MethodDeclaration;
+        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 = firstStatement;
+                extracted = lastStatement;
             }
-        } else if (firstStatement.kind === JS.Kind.ExpressionStatement) {
-            // If the first statement is an expression statement, extract the expression
-            extracted = (firstStatement as JS.ExpressionStatement).expression;
+        } 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 = firstStatement;
+            extracted = lastStatement;
         }
 
         // Attach CaptureMarkers to capture identifiers

package/src/javascript/templating/types.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {Cursor, Tree} from '../..';
-import {J} from '../../java';
+import {J, Type} from '../../java';
 
 /**
  * Options for variadic captures that match zero or more nodes in a sequence.
@@ -43,6 +43,16 @@ export interface CaptureOptions<T = any> {
     name?: string;
     variadic?: boolean | VariadicOptions;
     constraint?: (node: T) => boolean;
+    /**
+     * Type annotation for this capture. When provided, the template engine will generate
+     * a preamble declaring the capture identifier with this type annotation, allowing
+     * the TypeScript parser/compiler to produce a properly type-attributed AST.
+     *
+     * Can be specified as:
+     * - A string type annotation (e.g., "boolean", "string", "number")
+     * - A Type instance from the AST (the type will be inferred from the Type)
+     */
+    type?: string | Type;
 }
 
 /**

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);
         }
     }