@openrewrite/rewrite 8.96.4 → 8.97.0

package/src/javascript/add-import.ts

@@ -12,6 +12,7 @@ import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, i
 import {create as produce, Draft} from "mutative";
 import {autoFormat} from "./format";
 import {getPrettierStyle} from "./format/prettier-format";
+import ts from "typescript";
 
 export type QuoteChar = "'" | '"';
 
@@ -562,7 +563,8 @@ function claimedName(v: unknown): string | undefined {
 /**
  * The parser lifts surrogate pairs out of `valueSource` into `unicodeEscapes` and, when it does,
  * sets `value` to the quoted source (`parser.ts` `mapLiteral`), so neither field alone is the
- * module name. Reuniting them and stripping the quotes yields it for either shape of literal.
+ * module name. Reuniting them and reading the quoted text as the language does yields it for
+ * either shape of literal.
  */
 export function moduleNameOf(module: string | J.Literal): string {
     if (typeof module === 'string') {
@@ -579,6 +581,13 @@ export function moduleNameOf(module: string | J.Literal): string {
         cut = escape.valueSourceIndex;
     }
     restored += source.slice(cut);
+    // an escape such as `\u00dc` names the character it spells
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, restored);
+    const token = scanner.scan();
+    if ((token === ts.SyntaxKind.StringLiteral || token === ts.SyntaxKind.NoSubstitutionTemplateLiteral) &&
+        scanner.getTokenEnd() === restored.length) {
+        return scanner.getTokenValue();
+    }
     const quote = restored.charAt(0);
     return (quote === "'" || quote === '"' || quote === '`') && restored.endsWith(quote) && restored.length > 1
         ? restored.slice(1, -1)
@@ -1583,7 +1592,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             value: this.module,
             valueSource,
             unicodeEscapes: this.moduleUnicodeEscapes,
-            type: undefined
+            type: Type.Primitive.String
         };
     }
 

package/src/javascript/amd.ts

@@ -25,7 +25,8 @@ import {
     rightPadded,
     space,
     Statement,
-    TrailingComma
+    TrailingComma,
+    Type
 } from "../java";
 import {JS} from "./tree";
 import {moduleNameOf} from "./add-import";
@@ -428,7 +429,8 @@ function dependencyLiteral(module: string, quote: string): J.Literal {
         prefix: emptySpace,
         markers: emptyMarkers,
         value: module,
-        valueSource: `${quote}${module}${quote}`
+        valueSource: `${quote}${module}${quote}`,
+        type: Type.Primitive.String
     };
 }
 

package/src/javascript/cleanup/add-parse-int-radix.ts

@@ -18,7 +18,7 @@ import {Recipe} from "../../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {JavaScriptVisitor} from "../visitor";
-import {J, singleSpace} from "../../java";
+import {J, singleSpace, Type} from "../../java";
 import {emptyMarkers} from "../../markers";
 import {randomId} from "../../uuid";
 
@@ -73,7 +73,7 @@ export class AddParseIntRadix extends Recipe {
                     value: 10,
                     valueSource: '10',
                     unicodeEscapes: undefined,
-                    type: undefined
+                    type: Type.Primitive.Double
                 };
 
                 return {

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/format/format.ts

@@ -26,6 +26,7 @@ import {TabsAndIndentsVisitor} from "./tabs-and-indents-visitor";
 import {NormalizeWhitespaceVisitor} from "./normalize-whitespace-visitor";
 import {MinimumViableSpacingVisitor} from "./minimum-viable-spacing-visitor";
 import {applyPrettierFormatting, getPrettierStyle} from "./prettier-format";
+import {AsyncLocalStorage} from "node:async_hooks";
 
 export {TabsAndIndentsVisitor} from "./tabs-and-indents-visitor";
 export {NormalizeWhitespaceVisitor} from "./normalize-whitespace-visitor";
@@ -56,6 +57,22 @@ export const autoIndent = async <J2 extends J, P>(j: J2, p: P, parent?: Cursor):
     return await new TabsAndIndentsVisitor(style).visit(j, p, parent) as J2;
 }
 
+/**
+ * Hears about each request to auto-format a tree made while it listens, so that a test harness can check that a
+ * recipe formats only what it changed.
+ */
+export interface FormattingListener {
+    /** AutoformatVisitor calls this before it formats `tree`, stopping after `stopAfter` when it is given. */
+    onFormat(tree: Tree, stopAfter: Tree | undefined, cursor: Cursor | undefined): void;
+}
+
+const formattingListener = new AsyncLocalStorage<FormattingListener>();
+
+/** Runs `run`, telling `listener` about the formatting it requests. */
+export function listenToFormatting<T>(listener: FormattingListener, run: () => Promise<T>): Promise<T> {
+    return formattingListener.run(listener, run);
+}
+
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
  *
@@ -77,6 +94,7 @@ export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     async visit<R extends J>(tree: Tree, p: P, cursor?: Cursor): Promise<R | undefined> {
+        formattingListener.getStore()?.onFormat(tree, this.stopAfter, cursor);
         const prettierStyle = getPrettierStyle(tree, cursor, this.styles);
         if (prettierStyle) {
             const formatted = await applyPrettierFormatting(tree as R, prettierStyle, p, cursor, this.stopAfter);

package/src/javascript/format/tabs-and-indents-visitor.ts

@@ -408,6 +408,10 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             return literal;
         }
         return produce(literal, draft => {
+            // JSX text is its own value, as the parser makes it
+            if (draft.value === draft.valueSource) {
+                draft.value = normalizedValueSource;
+            }
             draft.valueSource = normalizedValueSource;
         });
     }

package/src/javascript/format/whitespace-reconciler.ts

@@ -416,6 +416,10 @@ export class WhitespaceReconciler {
         original: J.Identifier | J.Literal,
         formatted: J.Identifier | J.Literal
     ): J.Identifier | J.Literal {
+        // A literal's type follows from how it is written, so an identifier's is not the literal's
+        if (isLiteral(formatted)) {
+            return formatted;
+        }
         const result: Record<string, unknown> = { ...formatted };
 
         // Preserve type attribution - both Identifier and Literal have `type`

package/src/javascript/node-resolution-result.ts

@@ -19,6 +19,7 @@ import {asRef} from "../reference";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {castDraft} from "mutative";
 import {updateIfChanged} from "../util";
+import {registerHeavyweight} from "../heavyweight";
 import * as semver from "semver";
 import * as fsp from "fs/promises";
 import * as path from "path";
@@ -259,6 +260,8 @@ export interface NodeResolutionResult extends Marker {
     readonly npmrcConfigs?: Npmrc[];
 }
 
+registerHeavyweight(NodeResolutionResultKind);
+
 /**
  * Creates a NodeResolutionResult marker from a package.json file.
  * Should be called during parsing to attach to JS.CompilationUnit.

package/src/javascript/parser-utils.ts

@@ -17,7 +17,8 @@ import * as ts from "typescript";
 import {Expression, J, Statement} from "../java";
 import {JS} from "./tree";
 
-const is_statements = new Set<string>([
+// Built on first use, since ./tree imports the visitor, which imports this module
+const statementKinds = (): string[] => [
     J.Kind.Assert,
     J.Kind.Assignment,
     J.Kind.AssignmentOperation,
@@ -78,9 +79,9 @@ const is_statements = new Set<string>([
     JS.Kind.WithStatement,
     JS.Kind.ExpressionStatement,
     JS.Kind.StatementExpression
-])
+];
 
-const is_expressions = new Set<string>([
+const expressionKinds = (): string[] => [
     J.Kind.AnnotatedType,
     J.Kind.Annotation,
     J.Kind.ArrayAccess,
@@ -157,14 +158,17 @@ const is_expressions = new Set<string>([
     JS.Kind.Void,
     JS.Kind.ExpressionStatement,
     JS.Kind.StatementExpression
-])
+];
+
+let is_statements: Set<string> | undefined;
+let is_expressions: Set<string> | undefined;
 
 export function isStatement(statement: J):  statement is Statement {
-    return is_statements.has(statement.kind);
+    return (is_statements ??= new Set(statementKinds())).has(statement.kind);
 }
 
 export function isExpression(expression: J):  expression is Expression {
-    return is_expressions.has(expression.kind);
+    return (is_expressions ??= new Set(expressionKinds())).has(expression.kind);
 }
 
 export function getNextSibling(node: ts.Node): ts.Node | undefined {

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';
@@ -756,17 +770,22 @@ class MarkerAttachmentVisitor extends JavaScriptVisitor<undefined> {
 }
 
 // FIXME: This is a heuristic to determine if the parent expects a statement child
-function expectsStatement(parentTree: J): boolean {
+function expectsStatement(parentTree: J, childId: string): boolean {
+    if (parentTree.kind === J.Kind.Case) {
+        // the labels of a case are expressions
+        return !(parentTree as J.Case).caseLabels.elements.some(label => label.element.id === childId);
+    }
     return parentTree.kind === J.Kind.Block ||
-        parentTree.kind === J.Kind.Case ||
         parentTree.kind === J.Kind.DoWhileLoop ||
         parentTree.kind === J.Kind.ForEachLoop ||
         parentTree.kind === J.Kind.ForLoop ||
         parentTree.kind === J.Kind.If ||
         parentTree.kind === J.Kind.IfElse ||
+        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. */
@@ -782,7 +801,7 @@ export function replacedByObjectLiteral(tree: J, cursor: Cursor): boolean {
         return true;
     }
     const parentTree = cursor.parentTree()?.value;
-    return parentTree !== undefined && !expectsStatement(parentTree);
+    return parentTree !== undefined && !expectsStatement(parentTree, tree.id);
 }
 
 /**
@@ -913,9 +932,21 @@ 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);
+            const parentExpectsStatement = expectsStatement(parentTree, originalTree.id);
             const originalIsStatement = isStatement(originalTree);
 
             const resultIsStatement = isStatement(resultToUse);
@@ -935,8 +966,9 @@ export class TemplateApplier {
                         expression: { ...expression, prefix: emptySpace }
                     } as JS.ExpressionStatement;
                 }
-            } else if (!parentExpectsStatement) {
-                // Expression context: wrap in StatementExpression if result is statement-only
+            } else if (!parentExpectsStatement && isExpression(originalTree)) {
+                // Expression context: wrap in StatementExpression if result is statement-only. A slot that held
+                // a statement-only node, such as an arrow function's block body, takes one unwrapped.
                 if (resultIsStatement && !resultIsExpression) {
                     const stmt = resultToUse as Statement;
                     resultToUse = {

package/src/javascript/templating/pattern.ts

@@ -756,6 +756,16 @@ class Matcher {
                 opensWithBrace(this.pattern.templateParts) && this.ast.kind !== J.Kind.Block);
         }
 
+        // A visit reaches what parentheses hold right after them, so seeing through them here would match it twice
+        if ((this.ast.kind === J.Kind.Parentheses || this.ast.kind === J.Kind.ControlParentheses) &&
+            this.patternAst.kind !== this.ast.kind) {
+            if (this.debugOptions.enabled) {
+                this.setExplanation('kind-mismatch', 'An expression without parentheses',
+                    `Parentheses (${this.ast.kind.split('.').pop()})`,
+                    'The expression the parentheses hold is matched on its own');
+            }
+            return false;
+        }
         return this.matchNode(this.patternAst, this.ast);
     }
 

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

@@ -41,6 +41,25 @@ export class SubstitutedValue implements Marker {
 /** Chooses a substituted value's prefix, and says whether it is the source's own. */
 type MergePrefix = (sourcePrefix: J.Space, templatePrefix: J.Space) => [J.Space, boolean];
 
+/** Whether `value` is a property, method or spread of an object literal. */
+function isObjectMember(value: unknown): value is J {
+    switch (isTree(value) && value.kind) {
+        case JS.Kind.PropertyAssignment:
+        case JS.Kind.Spread:
+        case J.Kind.MethodDeclaration:
+        case JS.Kind.ComputedPropertyMethodDeclaration:
+            return true;
+    }
+    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.
  */
@@ -319,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' &&
@@ -331,6 +351,10 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                         else if (Array.isArray(param.value)) {
                             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 (member) {
+                            arrayToExpand = [member] as J[] | J.RightPadded<J>[];
+                        }
                         // Check if it's a CaptureValue
                         else if (param.value instanceof CaptureValue) {
                             const resolved = param.value.resolve(this.values);
@@ -435,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. */