@openrewrite/rewrite 8.68.0-20251124-203331 → 8.68.0-20251125-100455

package/src/javascript/dependency-workspace.ts

@@ -47,6 +47,42 @@ export class DependencyWorkspace {
             // Create/update workspace in target directory
             fs.mkdirSync(targetDir, {recursive: true});
 
+            // Check if we can reuse a cached workspace by symlinking node_modules
+            const hash = this.hashDependencies(dependencies);
+            const cachedWorkspaceDir = path.join(this.WORKSPACE_BASE, hash);
+            const cachedNodeModules = path.join(cachedWorkspaceDir, 'node_modules');
+
+            if (fs.existsSync(cachedNodeModules) && this.isWorkspaceValid(cachedWorkspaceDir, dependencies)) {
+                // Symlink node_modules from cached workspace
+                try {
+                    const targetNodeModules = path.join(targetDir, 'node_modules');
+
+                    // Remove existing node_modules if present (might be invalid)
+                    if (fs.existsSync(targetNodeModules)) {
+                        fs.rmSync(targetNodeModules, {recursive: true, force: true});
+                    }
+
+                    // Create symlink to cached node_modules
+                    fs.symlinkSync(cachedNodeModules, targetNodeModules, 'dir');
+
+                    // Write package.json
+                    const packageJson = {
+                        name: "openrewrite-template-workspace",
+                        version: "1.0.0",
+                        private: true,
+                        dependencies: dependencies
+                    };
+                    fs.writeFileSync(
+                        path.join(targetDir, 'package.json'),
+                        JSON.stringify(packageJson, null, 2)
+                    );
+
+                    return targetDir;
+                } catch (symlinkError) {
+                    // Symlink failed (e.g., cross-device, permissions) - fall through to npm install
+                }
+            }
+
             try {
                 const packageJson = {
                     name: "openrewrite-template-workspace",
@@ -214,6 +250,7 @@ export class DependencyWorkspace {
 
     /**
      * Checks if a workspace is valid (has node_modules and matching package.json).
+     * Handles both real node_modules directories and symlinks to cached workspaces.
      *
      * @param workspaceDir Directory to check
      * @param expectedDependencies Optional dependencies to check against package.json
@@ -222,10 +259,25 @@ export class DependencyWorkspace {
         const nodeModules = path.join(workspaceDir, 'node_modules');
         const packageJsonPath = path.join(workspaceDir, 'package.json');
 
+        // Check node_modules exists (as directory or symlink)
         if (!fs.existsSync(nodeModules) || !fs.existsSync(packageJsonPath)) {
             return false;
         }
 
+        // If node_modules is a symlink, verify the target still exists
+        try {
+            const stats = fs.lstatSync(nodeModules);
+            if (stats.isSymbolicLink()) {
+                const target = fs.readlinkSync(nodeModules);
+                const absoluteTarget = path.isAbsolute(target) ? target : path.resolve(path.dirname(nodeModules), target);
+                if (!fs.existsSync(absoluteTarget)) {
+                    return false;
+                }
+            }
+        } catch {
+            return false;
+        }
+
         // If dependencies provided, check if they match
         if (expectedDependencies) {
             try {

package/src/javascript/templating/pattern.ts

@@ -616,6 +616,17 @@ export class MatchResult implements IMatchResult {
         return this.extractElements(value);
     }
 
+    /**
+     * Checks if a capture has been matched.
+     *
+     * @param capture The capture name (string) or Capture object
+     * @returns true if the capture exists in the match result
+     */
+    has(capture: Capture | string): boolean {
+        const name = typeof capture === "string" ? capture : ((capture as any)[CAPTURE_NAME_SYMBOL] || capture.getName());
+        return this.storage.has(name);
+    }
+
     /**
      * Extracts semantic elements from storage value.
      * For wrappers, extracts the .element; for arrays, returns array of elements.

package/src/javascript/templating/rewrite.ts

@@ -15,7 +15,7 @@
  */
 import {Cursor, ExecutionContext, Recipe} from '../..';
 import {J} from '../../java';
-import {RewriteRule, RewriteConfig} from './types';
+import {RewriteRule, RewriteConfig, PreMatchContext, PostMatchContext} from './types';
 import {Pattern, MatchResult} from './pattern';
 import {Template} from './template';
 
@@ -26,28 +26,29 @@ class RewriteRuleImpl implements RewriteRule {
     constructor(
         private readonly before: Pattern[],
         private readonly after: Template | ((match: MatchResult) => Template),
-        private readonly where?: (node: J, cursor: Cursor) => boolean | Promise<boolean>,
-        private readonly whereNot?: (node: J, cursor: Cursor) => boolean | Promise<boolean>
+        private readonly preMatch?: (node: J, context: PreMatchContext) => boolean | Promise<boolean>,
+        private readonly postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>
     ) {
     }
 
     async tryOn(cursor: Cursor, node: J): Promise<J | undefined> {
+        // Evaluate preMatch before attempting any pattern matching
+        if (this.preMatch) {
+            const preMatchResult = await this.preMatch(node, { cursor });
+            if (!preMatchResult) {
+                return undefined; // Early exit - don't attempt pattern matching
+            }
+        }
+
         for (const pattern of this.before) {
             // Pass cursor to pattern.match() for context-aware capture constraints
             const match = await pattern.match(node, cursor);
             if (match) {
-                // Evaluate context predicates after structural match
-                if (this.where) {
-                    const whereResult = await this.where(node, cursor);
-                    if (!whereResult) {
-                        continue; // Pattern matched but context doesn't, try next pattern
-                    }
-                }
-
-                if (this.whereNot) {
-                    const whereNotResult = await this.whereNot(node, cursor);
-                    if (whereNotResult) {
-                        continue; // Pattern matched but context is excluded, try next pattern
+                // Evaluate postMatch after structural match succeeds
+                if (this.postMatch) {
+                    const postMatchResult = await this.postMatch(node, { cursor, captures: match });
+                    if (!postMatchResult) {
+                        continue; // Pattern matched but postMatch failed, try next pattern
                     }
                 }
 
@@ -69,7 +70,7 @@ class RewriteRuleImpl implements RewriteRule {
             }
         }
 
-        // Return undefined if no patterns match or all context checks failed
+        // Return undefined if no patterns match or all postMatch checks failed
         return undefined;
     }
 
@@ -168,8 +169,8 @@ export function rewrite(
     return new RewriteRuleImpl(
         Array.isArray(config.before) ? config.before : [config.before],
         config.after,
-        config.where,
-        config.whereNot
+        config.preMatch,
+        config.postMatch
     );
 }
 

package/src/javascript/templating/types.ts

@@ -590,6 +590,33 @@ export interface RewriteRule {
     orElse(alternative: RewriteRule): RewriteRule;
 }
 
+/**
+ * Context for preMatch predicate - only has cursor, no captures yet.
+ */
+export interface PreMatchContext {
+    /**
+     * The cursor pointing to the node being considered for matching.
+     * Allows navigating the AST (parent, root, etc.).
+     */
+    cursor: Cursor;
+}
+
+/**
+ * Context for postMatch predicate - has cursor and captured values.
+ */
+export interface PostMatchContext {
+    /**
+     * The cursor pointing to the matched node.
+     * Allows navigating the AST (parent, root, etc.).
+     */
+    cursor: Cursor;
+
+    /**
+     * Values captured during pattern matching.
+     */
+    captures: CaptureMap;
+}
+
 /**
  * Configuration for a replacement rule.
  */
@@ -598,55 +625,52 @@ export interface RewriteConfig {
     after: Template | ((match: MatchResult) => Template);
 
     /**
-     * Optional context predicate that must evaluate to true for the transformation to be applied.
-     * Evaluated after the pattern matches structurally but before applying the template.
-     * Provides access to both the matched node and the cursor for context inspection.
+     * Optional predicate evaluated BEFORE pattern matching.
+     * Use for efficient early filtering based on AST context when captures aren't needed.
+     * If this returns false, pattern matching is skipped entirely.
      *
-     * @param node The matched AST node
-     * @param cursor The cursor at the matched node, providing access to ancestors and context
-     * @returns true if the transformation should be applied, false otherwise
+     * @param node The AST node being considered for matching
+     * @param context Context providing cursor for AST navigation
+     * @returns true to proceed with pattern matching, false to skip this node
      *
      * @example
      * ```typescript
      * rewrite(() => ({
-     *     before: pattern`await ${_('promise')}`,
-     *     after: template`await ${_('promise')}.catch(handleError)`,
-     *     where: (node, cursor) => {
-     *         // Only apply inside async functions
-     *         const method = cursor.firstEnclosing((n: any): n is J.MethodDeclaration =>
-     *             n.kind === J.Kind.MethodDeclaration
-     *         );
-     *         return method?.modifiers.some(m => m.type === 'async') || false;
+     *     before: pattern`console.log(${_('msg')})`,
+     *     after: template`logger.info(${_('msg')})`,
+     *     preMatch: (node, {cursor}) => {
+     *         // Only attempt matching inside functions named 'handleError'
+     *         const method = cursor.firstEnclosing(isMethodDeclaration);
+     *         return method?.name.simpleName === 'handleError';
      *     }
      * }));
      * ```
      */
-    where?: (node: J, cursor: Cursor) => boolean | Promise<boolean>;
+    preMatch?: (node: J, context: PreMatchContext) => boolean | Promise<boolean>;
 
     /**
-     * Optional context predicate that must evaluate to false for the transformation to be applied.
-     * Evaluated after the pattern matches structurally but before applying the template.
-     * Provides access to both the matched node and the cursor for context inspection.
+     * Optional predicate evaluated AFTER pattern matching succeeds.
+     * Use when you need access to captured values to decide whether to apply the transformation.
+     * If this returns false, the transformation is not applied.
      *
      * @param node The matched AST node
-     * @param cursor The cursor at the matched node, providing access to ancestors and context
-     * @returns true if the transformation should NOT be applied, false if it should proceed
+     * @param context Context providing cursor for AST navigation and captured values
+     * @returns true to apply the transformation, false to skip
      *
      * @example
      * ```typescript
      * rewrite(() => ({
-     *     before: pattern`await ${_('promise')}`,
-     *     after: template`await ${_('promise')}.catch(handleError)`,
-     *     whereNot: (node, cursor) => {
-     *         // Don't apply inside try-catch blocks
-     *         return cursor.firstEnclosing((n: any): n is J.Try =>
-     *             n.kind === J.Kind.Try
-     *         ) !== undefined;
+     *     before: pattern`${_('a')} + ${_('b')}`,
+     *     after: template`${_('b')} + ${_('a')}`,
+     *     postMatch: (node, {cursor, captures}) => {
+     *         // Only swap if 'a' is a literal number
+     *         const a = captures.get('a');
+     *         return a?.kind === J.Kind.Literal && typeof a.value === 'number';
      *     }
      * }));
      * ```
      */
-    whereNot?: (node: J, cursor: Cursor) => boolean | Promise<boolean>;
+    postMatch?: (node: J, context: PostMatchContext) => boolean | Promise<boolean>;
 }
 
 /**
@@ -755,6 +779,14 @@ export interface MatchResult {
     get(capture: string): any;
 
     get<T>(capture: Capture<T>): T | undefined;
+
+    /**
+     * Checks if a capture has been matched.
+     *
+     * @param capture The capture name (string) or Capture object
+     * @returns true if the capture exists in the match result
+     */
+    has(capture: Capture | string): boolean;
 }
 
 /**

package/src/javascript/type-mapping.ts

@@ -65,6 +65,16 @@ export class JavaScriptTypeMapping {
     }
 
     type(node: ts.Node): Type | undefined {
+        // For identifiers, check if this references a variable
+        // This enables fieldType attribution for variable references
+        if (ts.isIdentifier(node)) {
+            const variableType = this.variableType(node);
+            if (variableType) {
+                return variableType;
+            }
+            // Fall through to regular type checking if not a variable
+        }
+
         let type: ts.Type | undefined;
         if (ts.isExpression(node)) {
             type = this.checker.getTypeAtLocation(node);
@@ -318,16 +328,229 @@ export class JavaScriptTypeMapping {
         return Type.isPrimitive(type) ? type : Type.Primitive.None;
     }
 
-    variableType(node: ts.NamedDeclaration): Type.Variable | undefined {
+    variableType(node: ts.Node): Type.Variable | undefined {
+        let symbol: ts.Symbol | undefined;
+        let location: ts.Node = node;
+
+        // Get the symbol depending on node type
         if (ts.isVariableDeclaration(node)) {
-            const symbol = this.checker.getSymbolAtLocation(node.name);
-            if (symbol) {
-                // TODO: Implement in Phase 6
-                // const type = this.checker.getTypeOfSymbolAtLocation(symbol, node);
-                // return JavaType.Variable with proper mapping
+            symbol = this.checker.getSymbolAtLocation(node.name);
+        } else if (ts.isParameter(node)) {
+            symbol = this.checker.getSymbolAtLocation(node.name);
+        } else if (ts.isIdentifier(node)) {
+            // For identifier references (like 'vi' in 'vi.fn()')
+            symbol = this.checker.getSymbolAtLocation(node);
+        } else if (ts.isPropertyDeclaration(node) || ts.isPropertySignature(node)) {
+            symbol = this.checker.getSymbolAtLocation(node.name);
+        } else {
+            // Not a variable/parameter/property we can handle
+            return undefined;
+        }
+
+        if (!symbol) {
+            return undefined;
+        }
+
+        // Get the variable declaration (resolve aliases if needed)
+        let actualSymbol = symbol;
+        if (symbol.flags & ts.SymbolFlags.Alias) {
+            actualSymbol = this.checker.getAliasedSymbol(symbol);
+        }
+
+        // Check if this symbol represents a variable, parameter, or property
+        // Exclude functions, classes, interfaces, namespaces, type aliases
+        const isExcluded = actualSymbol.flags & (
+            ts.SymbolFlags.Function |
+            ts.SymbolFlags.Class |
+            ts.SymbolFlags.Interface |
+            ts.SymbolFlags.Enum |
+            ts.SymbolFlags.ValueModule |
+            ts.SymbolFlags.NamespaceModule |
+            ts.SymbolFlags.TypeAlias |
+            ts.SymbolFlags.TypeParameter
+        );
+
+        if (isExcluded) {
+            // Not a variable - it's a type, function, class, namespace, etc.
+            return undefined;
+        }
+
+        const isVariable = actualSymbol.flags & (
+            ts.SymbolFlags.Variable |
+            ts.SymbolFlags.Property |
+            ts.SymbolFlags.FunctionScopedVariable |
+            ts.SymbolFlags.BlockScopedVariable
+        );
+
+        if (!isVariable) {
+            // Not a variable we recognize
+            return undefined;
+        }
+
+        // Get the type of the variable
+        const variableType = this.checker.getTypeOfSymbolAtLocation(actualSymbol, location);
+        const mappedType = this.getType(variableType);
+
+        // Get the owner (declaring type) for the variable
+        let ownerType: Type | undefined;
+
+        // Check if the variable is imported
+        if (symbol.flags & ts.SymbolFlags.Alias) {
+            // For imported variables, find the module specifier
+            const declarations = symbol.declarations;
+            if (declarations && declarations.length > 0) {
+                let importNode: ts.Node | undefined = declarations[0];
+
+                // Traverse up to find the ImportDeclaration
+                while (importNode && !ts.isImportDeclaration(importNode)) {
+                    importNode = importNode.parent;
+                }
+
+                if (importNode && ts.isImportDeclaration(importNode)) {
+                    const importDecl = importNode as ts.ImportDeclaration;
+                    if (ts.isStringLiteral(importDecl.moduleSpecifier)) {
+                        const moduleSpecifier = importDecl.moduleSpecifier.text;
+                        // Create a Type.Class representing the module
+                        ownerType = Object.assign(new NonDraftableType(), {
+                            kind: Type.Kind.Class,
+                            flags: 0,
+                            classKind: Type.Class.Kind.Interface,
+                            fullyQualifiedName: moduleSpecifier,
+                            typeParameters: [],
+                            annotations: [],
+                            interfaces: [],
+                            members: [],
+                            methods: [],
+                            toJSON: function () {
+                                return Type.signature(this);
+                            }
+                        }) as Type.Class;
+                    }
+                }
             }
+        } else {
+            // For non-imported variables, check if they belong to a class/interface/namespace
+            const parentSymbol = (actualSymbol as any).parent as ts.Symbol | undefined;
+            if (parentSymbol) {
+                const parentType = this.checker.getDeclaredTypeOfSymbol(parentSymbol);
+                if (parentType) {
+                    ownerType = this.getType(parentType);
+
+                    // If the parent is a namespace, try to find the module it came from
+                    // This handles cases like React.forwardRef where the namespace is React
+                    // but the module is "react"
+                    if (parentSymbol.flags & ts.SymbolFlags.ValueModule ||
+                        parentSymbol.flags & ts.SymbolFlags.NamespaceModule) {
+                        // Check if this namespace was imported
+                        const parentDeclarations = parentSymbol.declarations;
+                        if (parentDeclarations && parentDeclarations.length > 0) {
+                            const firstDecl = parentDeclarations[0];
+                            const sourceFile = firstDecl.getSourceFile();
+                            // If it's from node_modules or a .d.ts file, try to extract the module name
+                            if (sourceFile.isDeclarationFile) {
+                                const fileName = sourceFile.fileName;
+                                const moduleName = this.extractModuleNameFromPath(fileName);
+                                if (moduleName) {
+                                    // Store the module as the owningClass for now
+                                    // (This is a bit of a hack, but works with the current type system)
+                                    if (Type.isClass(ownerType)) {
+                                        (ownerType as any).owningClass = Object.assign(new NonDraftableType(), {
+                                            kind: Type.Kind.Class,
+                                            flags: 0,
+                                            classKind: Type.Class.Kind.Interface,
+                                            fullyQualifiedName: moduleName,
+                                            typeParameters: [],
+                                            annotations: [],
+                                            interfaces: [],
+                                            members: [],
+                                            methods: [],
+                                            toJSON: function () {
+                                                return Type.signature(this);
+                                            }
+                                        }) as Type.Class;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Create the Type.Variable
+        const variable = Object.assign(new NonDraftableType(), {
+            kind: Type.Kind.Variable,
+            name: actualSymbol.getName(),
+            owner: ownerType,
+            type: mappedType,
+            annotations: [],
+            toJSON: function () {
+                return Type.signature(this);
+            }
+        }) as Type.Variable;
+
+        return variable;
+    }
+
+    /**
+     * Extract the npm module name from a file path.
+     * Handles various package manager layouts:
+     * - Standard: /path/node_modules/react/index.d.ts -> react
+     * - Scoped: /path/node_modules/@types/react/index.d.ts -> react
+     * - Scoped with __ encoding: /path/node_modules/@types/testing-library__react/index.d.ts -> @testing-library/react
+     * - Nested node_modules: /path/node_modules/pkg/node_modules/dep/index.d.ts -> dep
+     * - pnpm: /path/node_modules/.pnpm/react@18.2.0/node_modules/react/index.d.ts -> react
+     *
+     * @returns The module name, or undefined if not from node_modules
+     */
+    private extractModuleNameFromPath(fileName: string): string | undefined {
+        if (!fileName.includes('node_modules/')) {
+            return undefined;
+        }
+
+        // Find the last occurrence of node_modules/ to handle nested dependencies
+        // This also correctly handles pnpm's .pnpm structure
+        const lastNodeModulesIndex = fileName.lastIndexOf('node_modules/');
+        const afterNodeModules = fileName.substring(lastNodeModulesIndex + 'node_modules/'.length);
+
+        // Split by '/' to get path segments
+        const segments = afterNodeModules.split('/');
+        if (segments.length === 0) {
+            return undefined;
+        }
+
+        let moduleName: string;
+
+        // Handle scoped packages (@scope/package)
+        if (segments[0].startsWith('@') && segments.length > 1) {
+            moduleName = `${segments[0]}/${segments[1]}`;
+        } else {
+            moduleName = segments[0];
         }
-        return undefined;
+
+        // Skip pnpm's .pnpm directory - it contains versioned package paths
+        // In pnpm, the actual package is in: .pnpm/pkg@version/node_modules/pkg
+        // So we already handled this by using lastIndexOf above
+        if (moduleName === '.pnpm') {
+            return undefined;
+        }
+
+        // Remove @types/ prefix and decode DefinitelyTyped scoped package encoding
+        // DefinitelyTyped encodes scoped packages using __ instead of /
+        // Example: @types/testing-library__react -> @testing-library/react
+        if (moduleName.startsWith('@types/')) {
+            moduleName = moduleName.substring('@types/'.length);
+            // Decode __ encoding for scoped packages
+            // testing-library__react -> @testing-library/react
+            if (moduleName.includes('__')) {
+                const parts = moduleName.split('__');
+                if (parts.length === 2) {
+                    moduleName = `@${parts[0]}/${parts[1]}`;
+                }
+            }
+        }
+
+        return moduleName;
     }
 
     /**