@openrewrite/rewrite 8.96.5 → 8.97.0

package/src/javascript/dependency-workspace.ts

@@ -229,6 +229,7 @@ export class DependencyWorkspace {
                     // Write package files
                     writePackageFiles(targetDir);
 
+                    this.markUsed(cachedWorkspaceDir);
                     return targetDir;
                 } catch (symlinkError) {
                     // Symlink failed (e.g., cross-device, permissions) - fall through to npm install
@@ -257,6 +258,7 @@ export class DependencyWorkspace {
         // Check cache
         const cached = this.cache.get(hash);
         if (cached && fs.existsSync(cached) && this.isWorkspaceValid(cached, depsForValidation)) {
+            this.markUsed(cached);
             return cached;
         }
 
@@ -266,6 +268,7 @@ export class DependencyWorkspace {
         // Check if valid workspace already exists on disk (cross-VM reuse)
         if (fs.existsSync(workspaceDir) && this.isWorkspaceValid(workspaceDir, depsForValidation)) {
             this.cache.set(hash, workspaceDir);
+            this.markUsed(workspaceDir);
             return workspaceDir;
         }
 
@@ -390,6 +393,19 @@ export class DependencyWorkspace {
         return crypto.createHash('sha256').update(content).digest('hex').substring(0, 16);
     }
 
+    /**
+     * Marks a workspace used now, so that a cleanup ages it from its last use rather than from its install, and never
+     * deletes one a test run or a recipe has just used.
+     */
+    private static markUsed(workspaceDir: string): void {
+        try {
+            const now = new Date();
+            fs.utimesSync(workspaceDir, now, now);
+        } catch {
+            // At worst, a cleanup deletes it once it is a day old, and it is installed again.
+        }
+    }
+
     /**
      * Checks if a workspace is valid (has node_modules and matching package.json).
      * Handles both real node_modules directories and symlinks to cached workspaces.
@@ -444,6 +460,15 @@ export class DependencyWorkspace {
                         return false;
                     }
                 }
+
+                // And installed: a workspace whose node_modules has lost a package, as a deletion cut short leaves
+                // one, would otherwise be reused without it, and nothing it declares would be type attributed. Its
+                // devDependencies are not asked for, which npm leaves out under NODE_ENV=production.
+                for (const name of Object.keys(packageJsonContent.dependencies ?? {})) {
+                    if (!fs.existsSync(path.join(nodeModules, name, 'package.json'))) {
+                        return false;
+                    }
+                }
             } catch (error) {
                 return false;
             }
@@ -454,11 +479,12 @@ export class DependencyWorkspace {
 
     /**
      * Cleans up old workspace directories.
-     * Removes workspaces older than the specified age.
+     * Removes workspaces unused for longer than the specified age, each moved out of its key's way before it is
+     * deleted, so that a deletion cut short leaves a temporary directory rather than part of a workspace.
      * Also removes all temporary directories (*.tmp-*) regardless of age,
      * as these indicate incomplete/crashed operations.
      *
-     * @param maxAgeMs Maximum age in milliseconds (default: 24 hours)
+     * @param maxAgeMs Maximum age in milliseconds since a workspace was last used (default: 24 hours)
      */
     static cleanupOldWorkspaces(maxAgeMs: number = 24 * 60 * 60 * 1000): void {
         if (!fs.existsSync(this.WORKSPACE_BASE)) {
@@ -508,7 +534,12 @@ export class DependencyWorkspace {
                 const age = now - stats.mtimeMs;
 
                 if (age > maxAgeMs) {
-                    fs.rmSync(workspaceDir, {recursive: true, force: true});
+                    // Out of its key's way in one rename, then deleted: a process looking the workspace up finds it
+                    // whole or not at all. A deletion cut short, as when the RPC server is killed while it shuts
+                    // down, then leaves a temporary directory of a process that has gone, which the next cleanup
+                    // removes, rather than a workspace that has lost part of its node_modules and still looks valid.
+                    const deleting = `${workspaceDir}.tmp-${process.pid}-${Date.now()}-deleting`;
+                    fs.renameSync(workspaceDir, deleting);
                     // Remove from cache
                     for (const [hash, dir] of this.cache.entries()) {
                         if (dir === workspaceDir) {
@@ -516,6 +547,7 @@ export class DependencyWorkspace {
                             break;
                         }
                     }
+                    fs.rmSync(deleting, {recursive: true, force: true});
                 }
             } catch (error) {
                 // Ignore errors, workspace might be in use

package/src/javascript/templating/engine.ts

@@ -481,9 +481,15 @@ export class TemplateEngine {
      * Converts a Type instance to a TypeScript type string.
      *
      * @param type The Type instance
+     * @param enclosing The types that `type` is a type argument or element type of
      * @returns A TypeScript type string
      */
-    private static typeToString(type: Type): string {
+    private static typeToString(type: Type, enclosing: Type[] = []): string {
+        // A recursive type, such as `type A = Array<A>`, is any where it holds itself
+        if (enclosing.includes(type)) {
+            return 'any';
+        }
+
         // 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;
@@ -518,10 +524,18 @@ export class TemplateEngine {
         // 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);
+            const componentTypeString = this.typeToString(arrayType.elemType, [...enclosing, type]);
             return `${componentTypeString}[]`;
         }
 
+        // An array, a map or any other generic type, with its type arguments
+        if (type.kind === Type.Kind.Parameterized) {
+            const parameterized = type as Type.Parameterized;
+            const base = this.typeToString(parameterized.type);
+            return base === 'any' || parameterized.typeParameters.length === 0 ? base :
+                `${base}<${parameterized.typeParameters.map(t => this.typeToString(t, [...enclosing, type])).join(', ')}>`;
+        }
+
         // For other types, return 'any' as a fallback
         // TODO: Implement proper Type to string conversion for other Type.Kind values
         return 'any';
@@ -770,7 +784,8 @@ function expectsStatement(parentTree: J, childId: string): boolean {
         parentTree.kind === J.Kind.Label ||
         parentTree.kind === J.Kind.WhileLoop ||
         parentTree.kind === JS.Kind.CompilationUnit ||
-        parentTree.kind === JS.Kind.ForInLoop;
+        parentTree.kind === JS.Kind.ForInLoop ||
+        parentTree.kind === JS.Kind.WithStatement;
 }
 
 /** Whether the code opens with `{`, which is a block where a statement goes and an object literal elsewhere. */
@@ -917,6 +932,18 @@ export class TemplateApplier {
     private wrapTree(originalTree: J, resultToUse: J) {
         const parentTree = this.cursor?.parentTree()?.value;
 
+        // A `for` head holds each expression of its init and update in an expression statement, as the parser does
+        if (parentTree?.kind === J.Kind.ForLoopControl &&
+            (parentTree as J.ForLoop.Control).condition?.element.id !== originalTree.id) {
+            return isExpression(resultToUse) && resultToUse.kind !== JS.Kind.ExpressionStatement ? {
+                kind: JS.Kind.ExpressionStatement,
+                id: randomId(),
+                prefix: resultToUse.prefix,
+                markers: wrapperMarkers(resultToUse),
+                expression: {...resultToUse, prefix: emptySpace}
+            } as JS.ExpressionStatement : resultToUse;
+        }
+
         // Only apply wrapping logic if we have parent context
         if (parentTree) {
             const parentExpectsStatement = expectsStatement(parentTree, originalTree.id);

package/src/javascript/templating/placeholder-replacement.ts

@@ -53,6 +53,13 @@ function isObjectMember(value: unknown): value is J {
     return false;
 }
 
+/** `padded` less the trailing comma it brought from the end of the list it was taken from. */
+function withoutTrailingComma(padded: J.RightPadded<J>): J.RightPadded<J> {
+    const markers = padded.markers?.markers;
+    return markers?.some(m => m.kind === J.Markers.TrailingComma) ?
+        {...padded, markers: {...padded.markers, markers: markers.filter(m => m.kind !== J.Markers.TrailingComma)}} : padded;
+}
+
 /**
  * Visitor that replaces placeholder nodes with actual parameter values.
  */
@@ -331,6 +338,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                     const param = this.substitutions.get(placeholderText);
                     if (param) {
                         let arrayToExpand: J[] | J.RightPadded<J>[] | undefined = undefined;
+                        const member = element.kind === JS.Kind.PropertyAssignment ? this.objectMember(param.value) : undefined;
 
                         // Check if it's a J.Container
                         const isContainer = param.value && typeof param.value === 'object' &&
@@ -344,8 +352,8 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                             arrayToExpand = param.value as J[];
                         }
                         // One member of an object literal fills the slot of a member, not the name of a property
-                        else if (element.kind === JS.Kind.PropertyAssignment && isObjectMember(param.value)) {
-                            arrayToExpand = [param.value];
+                        else if (member) {
+                            arrayToExpand = [member] as J[] | J.RightPadded<J>[];
                         }
                         // Check if it's a CaptureValue
                         else if (param.value instanceof CaptureValue) {
@@ -451,7 +459,20 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
             }
         }
 
-        return newElements;
+        // Only the last element prints the trailing comma that a given or captured padding brings along
+        return newElements.map((padded, i) => i === newElements.length - 1 ? padded : withoutTrailingComma(padded));
+    }
+
+    /** The member of an object literal, padded or not, that a parameter is or is bound to, if it is one. */
+    private objectMember(value: any): J | J.RightPadded<J> | undefined {
+        if (value instanceof CaptureValue) {
+            value = value.resolve(this.values);
+        } else if (value instanceof TemplateParamImpl) {
+            value = this.values.get(value.name);
+        } else if (value instanceof CaptureImpl || (value && typeof value === 'object' && value[CAPTURE_NAME_SYMBOL])) {
+            value = this.values.get(value[CAPTURE_NAME_SYMBOL] || value.name);
+        }
+        return isObjectMember(value?.kind === J.Kind.RightPadded ? value.element : value) ? value : undefined;
     }
 
     /** As `visit` on a placeholder, with `merge` choosing the replacement's prefix. */