@openrewrite/rewrite 8.92.2 → 8.92.4

package/src/recipe.ts

@@ -21,6 +21,12 @@ import {mapAsync} from "./util";
 
 const OPTIONS_KEY = "__recipe_options__";
 
+/**
+ * Java's OptionDescriptor declares `type` non-nullable, so an option omitting one
+ * degrades to String rather than reporting no type.
+ */
+export const DEFAULT_OPTION_TYPE = "String";
+
 export type Minutes = number;
 
 export abstract class Recipe {
@@ -100,6 +106,7 @@ export abstract class Recipe {
                 name: key,
                 value: (this as any)[key],
                 required: descriptor.required ?? true,
+                type: descriptor.type ?? DEFAULT_OPTION_TYPE,
                 ...descriptor
             })),
             preconditions: [],
@@ -154,6 +161,12 @@ export interface OptionDescriptor {
     readonly required?: boolean
     readonly example?: string
     readonly valid?: string[]
+
+    /**
+     * Java simple type name, for example String, Long or Boolean. TypeScript erases types at
+     * runtime, so this cannot be derived; defaults to {@link DEFAULT_OPTION_TYPE}.
+     */
+    readonly type?: string
 }
 
 export abstract class ScanningRecipe<P> extends Recipe {

package/src/rpc/queue.ts

@@ -316,6 +316,60 @@ 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;
@@ -325,7 +379,8 @@ export class RpcReceiveQueue {
                 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()) {
     }
 
     /**
@@ -432,7 +487,9 @@ export class RpcReceiveQueue {
                 } else if ((codec = RpcCodecs.forInstance(before, this.sourceFileType))) {
                     after = await codec.rpcReceive(before, this);
                 } else if (message.value !== undefined) {
-                    after = message.valueType ? {kind: message.valueType, ...message.value} : message.value;
+                    after = message.valueType ?
+                        {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}'. ` +
@@ -515,7 +572,7 @@ export class RpcReceiveQueue {
         if (codec?.rpcNew) {
             return codec.rpcNew();
         }
-        return {kind: type} as T;
+        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/uuid.ts

@@ -35,12 +35,19 @@ function fallbackRandomId(): UUID {
 }
 
 /**
- * Generate a random UUID v4.
- *
  * Uses native crypto.randomUUID() on Node 14.17.0+, falls back to
  * crypto.randomBytes() on older versions. The implementation is
  * selected once at module load time to avoid per-call overhead.
  */
-export const randomId: () => UUID = typeof crypto.randomUUID === 'function'
+const generateId: () => UUID = typeof crypto.randomUUID === 'function'
     ? crypto.randomUUID
     : fallbackRandomId;
+
+/**
+ * Generate a random UUID v4.
+ */
+export const randomId: () => UUID = () =>
+    // Both randomUUID() and concatenation yield an unflattened cons-string. An id is only ever
+    // compared or serialized, so nothing forces a flatten and each would be retained as a rope of
+    // tiny heap nodes for the life of the LST; the round-trip flattens it to a sequential string.
+    Buffer.from(generateId(), 'latin1').toString('latin1');