@openrewrite/rewrite 8.92.3 → 8.92.5

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.
@@ -316,18 +318,71 @@ export class RpcSendQueue {
     }
 }
 
+/**
+ * Collapses repeated strings decoded from RPC messages to a single instance. Shared across every
+ * {@link RpcReceiveQueue} of a connection so the same discriminators, enum values and whitespace
+ * are deduplicated across the whole run rather than only within one received object.
+ */
+export class StringInternTable {
+    private readonly strings = new Map<string, string>();
+
+    constructor(private readonly maxEntries = 1 << 16,
+                private readonly maxValueLength = 200) {
+    }
+
+    /**
+     * Interns a `kind`/`valueType` discriminator. This set is bounded by the number of LST node
+     * types, so it is always interned and never subject to the cap.
+     */
+    internType(value: string): string {
+        const existing = this.strings.get(value);
+        if (existing !== undefined) {
+            return existing;
+        }
+        this.strings.set(value, value);
+        return value;
+    }
+
+    /**
+     * Interns a scalar string value, which is unbounded in principle. Only short strings are
+     * interned (whitespace and short tokens dominate the duplication), and the table stops growing
+     * at a cap so it can never turn into a leak; past either limit the original is returned as-is.
+     */
+    internValue(value: string): string {
+        if (value.length > this.maxValueLength) {
+            return value;
+        }
+        const existing = this.strings.get(value);
+        if (existing !== undefined) {
+            return existing;
+        }
+        if (this.strings.size >= this.maxEntries) {
+            return value;
+        }
+        this.strings.set(value, value);
+        return value;
+    }
+
+    clear(): void {
+        this.strings.clear();
+    }
+
+    get size(): number {
+        return this.strings.size;
+    }
+}
+
 export class RpcReceiveQueue {
     private batch: RpcObjectData[] = [];
     private batchIndex = 0;
     private sinceYield = 0;
 
-    private readonly internedStrings = new Map<string, string>();
-
     constructor(private readonly refs: Map<number, any>,
                 private readonly sourceFileType: string | undefined,
                 private readonly pull: () => Promise<RpcObjectData[]>,
                 private readonly logger: rpc.Logger | undefined,
-                private readonly trace: boolean) {
+                private readonly trace: boolean,
+                private readonly internedStrings: StringInternTable = new StringInternTable()) {
     }
 
     /**
@@ -371,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});
             })
         })
     }
@@ -435,8 +492,8 @@ export class RpcReceiveQueue {
                     after = await codec.rpcReceive(before, this);
                 } else if (message.value !== undefined) {
                     after = message.valueType ?
-                        {kind: this.intern(message.valueType), ...message.value} :
-                        typeof message.value === "string" ? this.intern(message.value) : message.value;
+                        {kind: this.internedStrings.internType(message.valueType), ...message.value} :
+                        typeof message.value === "string" ? this.internedStrings.internValue(message.value) : message.value;
                 } else if (message.state === RpcObjectState.ADD && message.valueType) {
                     throw new Error(
                         `No RPC codec registered on the TypeScript side for '${message.valueType}'. ` +
@@ -463,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>(
@@ -501,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];
@@ -519,16 +579,7 @@ export class RpcReceiveQueue {
         if (codec?.rpcNew) {
             return codec.rpcNew();
         }
-        return {kind: this.intern(type)} as T;
-    }
-
-    private intern(value: string): string {
-        const existing = this.internedStrings.get(value);
-        if (existing !== undefined) {
-            return existing;
-        }
-        this.internedStrings.set(value, value);
-        return value;
+        return {kind: this.internedStrings.internType(type)} as T;
     }
 }
 

package/src/rpc/rewrite-rpc.ts

@@ -40,7 +40,7 @@ import {
 import {DataTableStore} from "../data-table";
 import {RecipeMarketplace} from "../marketplace";
 import {initializeMetricsCsv, setCacheSizeProvider} from "./request/metrics";
-import {RpcObjectData, RpcObjectState, RpcReceiveQueue} from "./queue";
+import {RpcObjectData, RpcObjectState, RpcReceiveQueue, StringInternTable} from "./queue";
 import {RpcRecipe} from "./recipe";
 import {ExecutionContext} from "../execution";
 import {InstallRecipes, InstallRecipesResponse} from "./request/install-recipes";
@@ -68,6 +68,11 @@ export class RewriteRpc {
     readonly remoteRefs: Map<number, any> = new Map();
     readonly localRefs: ReferenceMap = new ReferenceMap();
 
+    // One table for the whole connection so repeated discriminators, enum values and whitespace
+    // decoded across the many getObject calls of a run collapse to a single string instance rather
+    // than one per received object.
+    private readonly internedStrings = new StringInternTable();
+
     // Ref high-water per source file, captured before it is first visited so an Evict rolls
     // back exactly the refs it introduced. `send` = localRefs snapshot, `recvMax` = max remoteRefs key.
     readonly refCheckpoints: Map<string, { send: number, recvMax: number }> = new Map();
@@ -158,6 +163,7 @@ export class RewriteRpc {
             this.remoteRefs.clear();
             this.localRefs.clear();
             this.refCheckpoints.clear();
+            this.internedStrings.clear();
             preparedRecipes.clear();
             this.remoteLanguages = undefined;
         };
@@ -262,7 +268,7 @@ export class RewriteRpc {
                 nextPage = requestPage();
             }
             return page;
-        }, this.logger, this.traceGetObject.receive);
+        }, this.logger, this.traceGetObject.receive, this.internedStrings);
 
         let remoteObject: P;
         try {

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