@openrewrite/rewrite 8.92.4 → 8.92.6

package/src/javascript/add-import.ts

@@ -1,8 +1,8 @@
 import {JavaScriptVisitor} from "./visitor";
-import {ElementRemovalFormatter, emptySpace, isIdentifier, J, NameTree, rightPadded, singleSpace, space, Statement, Type} from "../java";
+import {ElementRemovalFormatter, emptySpace, isIdentifier, J, NameTree, rightPadded, singleSpace, space, Statement, TrailingComma, Type} from "../java";
 import {JS, JSX} from "./tree";
 import {randomId, UUID} from "../uuid";
-import {emptyMarkers, markers} from "../markers";
+import {emptyMarkers, findMarker, markers} from "../markers";
 import {getStyle, SpacesStyle, StyleKind} from "./style";
 import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, isValueReference, namesDeclaredIn, scopeOf, walk} from "./scope";
 import {create as produce, Draft} from "mutative";
@@ -940,7 +940,10 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                         // - trailingSpace: space before } (from last element's after)
                         const firstElementPrefix = existingElements[0]?.element?.prefix ?? emptySpace;
                         const lastIndex = existingElements.length - 1;
-                        const trailingSpace = existingElements[lastIndex].after;
+                        // A trailing comma is a marker on the last element rather than padding, so with
+                        // one present the space before `}` lives in the marker's suffix, not in `after`.
+                        const trailingComma = findMarker<TrailingComma>(existingElements[lastIndex], J.Markers.TrailingComma);
+                        const trailingSpace = trailingComma ? trailingComma.suffix : existingElements[lastIndex].after;
 
                         // Build the new elements array with proper spacing
                         const updatedNamedImports: JS.NamedImports = await this.produceJavaScript(
@@ -961,9 +964,18 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                                     if (j === 0 && insertIndex === 0 && elem.element) {
                                         adjusted = {...elem, element: {...elem.element, prefix: singleSpace}};
                                     }
-                                    // Last element before a new trailing element loses its trailing space
+                                    // Last element before a new trailing element loses its trailing space,
+                                    // and hands off its trailing comma to the element that becomes last.
                                     if (j === lastIndex && insertIndex > lastIndex) {
-                                        adjusted = {...adjusted, after: emptySpace};
+                                        adjusted = trailingComma ?
+                                            {
+                                                ...adjusted,
+                                                markers: {
+                                                    ...adjusted.markers,
+                                                    markers: adjusted.markers.markers.filter(m => m !== trailingComma)
+                                                }
+                                            } :
+                                            {...adjusted, after: emptySpace};
                                     }
                                     results.push(adjusted);
                                     return results;
@@ -971,7 +983,12 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
                                 // Append at end if inserting after all existing elements
                                 if (insertIndex > lastIndex) {
-                                    newElements.push(rightPadded({...newSpecifier, prefix: singleSpace}, trailingSpace));
+                                    const appended = rightPadded(
+                                        {...newSpecifier, prefix: singleSpace},
+                                        trailingComma ? emptySpace : trailingSpace);
+                                    newElements.push(trailingComma ?
+                                        {...appended, markers: markers(trailingComma)} :
+                                        appended);
                                 }
 
                                 namedDraft.elements = {...namedImports.elements, elements: newElements};

package/src/javascript/type-mapping.ts

@@ -693,6 +693,38 @@ export class JavaScriptTypeMapping {
         return variable;
     }
 
+    /**
+     * The module specifier of a `require('module')` call, or undefined for anything else.
+     *
+     * `require` is declared to return `any`, so the checker carries no module type through it and
+     * the specifier in the call is the only thing identifying the module.
+     */
+    private requiredModuleSpecifier(node: ts.Expression): string | undefined {
+        if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression) ||
+            node.expression.text !== 'require' || node.arguments.length === 0) {
+            return undefined;
+        }
+        const moduleArg = node.arguments[0];
+        return ts.isStringLiteral(moduleArg) ? moduleArg.text : undefined;
+    }
+
+    /**
+     * The module an expression evaluates to where that is a `require()` result — either the call
+     * itself (`require('x').fn()`) or an identifier bound to one (`const x = require('x')`).
+     */
+    private requiredModuleOfExpression(node: ts.Expression): string | undefined {
+        const direct = this.requiredModuleSpecifier(node);
+        if (direct) {
+            return direct;
+        }
+        if (!ts.isIdentifier(node)) {
+            return undefined;
+        }
+        const valueDecl = this.checker.getSymbolAtLocation(node)?.valueDeclaration;
+        return valueDecl && ts.isVariableDeclaration(valueDecl) && valueDecl.initializer ?
+            this.requiredModuleSpecifier(valueDecl.initializer) : undefined;
+    }
+
     /**
      * Extract the npm module name from a file path.
      * Handles various package manager layouts:
@@ -891,41 +923,14 @@ export class JavaScriptTypeMapping {
                     // where the module is typed as 'any' but methods still have signatures
 
                     // Try to trace back through the AST to find the require() call
-                    let inferredDeclaringType: Type.FullyQualified | undefined;
-                    const objExpr = node.expression.expression;
-
-                    if (ts.isIdentifier(objExpr)) {
-                        // Look for the variable declaration that assigns the require() result
-                        const objSymbol = this.checker.getSymbolAtLocation(objExpr);
-
-                        if (objSymbol && objSymbol.valueDeclaration) {
-                            const valueDecl = objSymbol.valueDeclaration;
-                            if (ts.isVariableDeclaration(valueDecl) && valueDecl.initializer) {
-                                // Check if it's a require() call
-                                if (ts.isCallExpression(valueDecl.initializer)) {
-                                    const callExpr = valueDecl.initializer;
-                                    if (ts.isIdentifier(callExpr.expression) &&
-                                        callExpr.expression.getText() === 'require' &&
-                                        callExpr.arguments.length > 0) {
-                                        // Extract the module name from require('module-name')
-                                        const moduleArg = callExpr.arguments[0];
-                                        if (ts.isStringLiteral(moduleArg)) {
-                                            const moduleName = moduleArg.text;
-
-                                            inferredDeclaringType = {
-                                                kind: Type.Kind.Class,
-                                                flags: 0, // TODO - determine flags
-                                                fullyQualifiedName: moduleName
-                                            } as Type.FullyQualified;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
+                    const moduleName = this.requiredModuleOfExpression(node.expression.expression);
 
                     // Use the inferred type or fall back to unknown
-                    declaringType = inferredDeclaringType || Type.unknownType as Type.FullyQualified;
+                    declaringType = moduleName ? {
+                        kind: Type.Kind.Class,
+                        flags: 0, // TODO - determine flags
+                        fullyQualifiedName: moduleName
+                    } as Type.FullyQualified : Type.unknownType as Type.FullyQualified;
 
                     // Create the method type using the helper
                     return this.createMethodType(signature, node, declaringType, methodName);
@@ -985,6 +990,19 @@ export class JavaScriptTypeMapping {
                     declaringType = Type.unknownType as Type.FullyQualified;
                 }
 
+                // A `require()` result is typed `any`, so nothing above identifies the module; the
+                // specifier in the call does.
+                if (declaringType === Type.unknownType) {
+                    const moduleName = this.requiredModuleOfExpression(node.expression.expression);
+                    if (moduleName) {
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            flags: 0, // TODO - determine flags
+                            fullyQualifiedName: moduleName
+                        } as Type.FullyQualified;
+                    }
+                }
+
                 // For string methods like 'hello'.split(), ensure we have a proper declaring type for primitives
                 if (!isImport && declaringType === Type.unknownType) {
                     // If the expression type is a primitive string, use String as declaring type
@@ -1294,9 +1312,14 @@ export class JavaScriptTypeMapping {
                 // file's node_modules path) match the names used for directly imported types.
                 packageName = this.normalizePackageName(packageName);
 
-                // Find the symbol name (everything after the last dot in the original cleaned name)
+                // The symbol name is appended to the declaration file's path, so it is whatever
+                // follows the last dot of the final path segment. Directory names carry dots of
+                // their own — `.pnpm`, `.yarn`, a hidden parent such as `.claude`, a versioned
+                // pnpm directory — so a search over the whole path would split there instead and
+                // fold most of the path into the name.
+                const lastSegmentIndex = cleanedName.lastIndexOf('/') + 1;
                 const lastDotIndex = cleanedName.lastIndexOf('.');
-                if (lastDotIndex > 0) {
+                if (lastDotIndex > lastSegmentIndex) {
                     const symbolName = cleanedName.substring(lastDotIndex + 1);
                     cleanedName = `${packageName}.${symbolName}`;
                 } else {

package/src/rpc/index.ts

@@ -16,6 +16,7 @@
 import {Checksum, FileAttributes, TreeKind} from "../tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "./queue";
 import {
+    emptyMarkers,
     Markers,
     MarkersKind,
     MarkupDebug,
@@ -76,10 +77,12 @@ RpcCodecs.registerCodec(TreeKind.FileAttributes, {
 
 RpcCodecs.registerCodec(MarkersKind.Markers, {
     async rpcReceive(before: Markers, q: RpcReceiveQueue): Promise<Markers> {
-        return updateIfChanged(before, {
-            id: await q.receive(before.id),
-            markers: (await q.receiveList(before.markers))!,
-        });
+        const id = await q.receive(before.id);
+        const markers = (await q.receiveList(before.markers))!;
+        if (markers.length === 0) {
+            return emptyMarkers;
+        }
+        return updateIfChanged(before, {id, markers});
     },
 
     async rpcSend(after: Markers, q: RpcSendQueue): Promise<void> {

package/src/rpc/queue.ts

@@ -19,6 +19,8 @@ import {saveTrace, trace} from "./trace";
 import {updateIfChanged} from "../util";
 import {isRef, ReferenceMap} from "../reference";
 
+const EMPTY_LIST: readonly never[] = Object.freeze([]);
+
 /**
  * Interface representing an RPC codec that defines methods
  * for sending and receiving objects in an RPC communication.
@@ -424,10 +426,12 @@ export class RpcReceiveQueue {
         }
         return this.receive(markers, async m => {
             return saveTrace(this.trace, async () => {
-                return updateIfChanged(markers!, {
-                    id: await this.receive(m.id),
-                    markers: (await this.receiveList(m.markers))!,
-                });
+                const id = await this.receive(m.id);
+                const markerList = (await this.receiveList(m.markers))!;
+                if (markerList.length === 0) {
+                    return emptyMarkers;
+                }
+                return updateIfChanged(markers!, {id, markers: markerList});
             })
         })
     }
@@ -516,7 +520,7 @@ export class RpcReceiveQueue {
         before: T[] | undefined,
         onChange?: (before: T) => T | Promise<T | undefined> | undefined
     ): Promise<T[]> {
-        return (await this.receiveList(before, onChange)) ?? [];
+        return (await this.receiveList(before, onChange)) ?? (EMPTY_LIST as unknown as T[]);
     }
 
     receiveList<T>(
@@ -554,6 +558,9 @@ export class RpcReceiveQueue {
                 if (!positions) {
                     throw new Error(`Expected positions array but got: ${JSON.stringify(d)}`);
                 }
+                if (positions.length === 0) {
+                    return EMPTY_LIST as unknown as T[];
+                }
                 const after: T[] = new Array(positions.length);
                 for (let i = 0; i < positions.length; i++) {
                     const beforeIdx = positions[i];

package/src/util.ts

@@ -50,16 +50,66 @@ export function trimIndent(str: string | null | undefined): string {
         .trim();
 }
 
+/**
+ * A compiled `(original, updates) => merged` builder that names every resulting property in an
+ * object literal. V8 sizes a literal's in-object storage to the properties it names, so the merged
+ * node keeps its fields inline; the `{...original, ...updates}` spread of a shared, megamorphic
+ * function instead lands in an out-of-object `system / PropertyArray` (millions of them across an
+ * RPC-received LST forest). Builders are keyed and cached by the pair of property-name lists so a
+ * given shape compiles once.
+ */
+type MergeBuilder = (original: any, updates: any) => any;
+
+const mergeBuilders = new Map<string, MergeBuilder>();
+
+function mergeBuilderFor(originalKeys: string[], updateKeys: string[]): MergeBuilder | undefined {
+    const cacheKey = JSON.stringify(originalKeys) + JSON.stringify(updateKeys);
+    let builder = mergeBuilders.get(cacheKey);
+    if (builder === undefined) {
+        const fromUpdates = new Set(updateKeys);
+        const names = originalKeys.slice();
+        for (const key of updateKeys) {
+            if (!names.includes(key)) {
+                names.push(key);
+            }
+        }
+        const body = "return {" + names
+            .map(name => `${JSON.stringify(name)}:(${fromUpdates.has(name) ? "u" : "o"})[${JSON.stringify(name)}]`)
+            .join(",") + "};";
+        try {
+            builder = new Function("o", "u", body) as MergeBuilder;
+        } catch {
+            builder = (o, u) => ({...o, ...u});
+        }
+        mergeBuilders.set(cacheKey, builder);
+    }
+    return builder;
+}
+
 /**
  * Helper function to create a new object only if any properties have changed.
  * Compares each property in updates with the original object.
  * Returns the original object if nothing changed, or a new object with updates applied.
  */
 export function updateIfChanged<O extends object>(original: O, updates: Partial<O>): O {
+    let changed = false;
     for (const key in updates) {
         if (updates[key] !== original[key]) {
-            return { ...original, ...updates };
+            changed = true;
+            break;
+        }
+    }
+    if (!changed) {
+        return original;
+    }
+    // A merged node built through a shared spread overflows into a PropertyArray; a compiled
+    // literal builder keeps its fields inline. Symbol-keyed originals fall back to the spread,
+    // since only string keys survive the JSON-serialized builder body.
+    if (typeof original === "object" && Object.getOwnPropertySymbols(original).length === 0) {
+        const builder = mergeBuilderFor(Object.keys(original), Object.keys(updates as object));
+        if (builder !== undefined) {
+            return builder(original, updates);
         }
     }
-    return original;
+    return {...original, ...updates};
 }