@openrewrite/rewrite 8.62.0 → 8.62.2

package/src/javascript/visitor.ts

@@ -18,7 +18,7 @@
 import {mapAsync} from "../util";
 import {SourceFile} from "../tree";
 import {ValidImmerRecipeReturnType} from "../visitor";
-import {Expression, J, JavaType, JavaVisitor, NameTree, Statement, TypedTree} from "../java";
+import {Expression, J, Type, JavaVisitor, NameTree, Statement, TypedTree} from "../java";
 import {createDraft, Draft, finishDraft} from "immer";
 import {isJavaScript, JS, JSX} from "./tree";
 import ComputedPropertyName = JS.ComputedPropertyName;
@@ -45,7 +45,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
     }
 
     // noinspection JSUnusedLocalSymbols
-    protected override async visitType(javaType: JavaType | undefined, p: P): Promise<JavaType | undefined> {
+    protected override async visitType(javaType: Type | undefined, p: P): Promise<Type | undefined> {
         return javaType;
     }
 
@@ -254,7 +254,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             draft.function = await this.visitOptionalRightPadded(functionCall.function, p);
             draft.typeParameters = await this.visitOptionalContainer(functionCall.typeParameters, p);
             draft.arguments = await this.visitContainer(functionCall.arguments, p);
-            draft.functionType = await this.visitType(functionCall.functionType, p) as JavaType.Method | undefined;
+            draft.functionType = await this.visitType(functionCall.functionType, p) as Type.Method | undefined;
         });
     }
 
@@ -785,7 +785,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             draft.name = await this.visitDefined<ComputedPropertyName>(computedPropMethod.name, p);
             draft.parameters = await this.visitContainer(computedPropMethod.parameters, p);
             draft.body = computedPropMethod.body && await this.visitDefined<J.Block>(computedPropMethod.body, p);
-            draft.methodType = computedPropMethod.methodType && (await this.visitType(computedPropMethod.methodType, p) as JavaType.Method);
+            draft.methodType = computedPropMethod.methodType && (await this.visitType(computedPropMethod.methodType, p) as Type.Method);
         });
     }
 
@@ -842,7 +842,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
             draft.propertyName = bindingElement.propertyName && await this.visitRightPadded(bindingElement.propertyName, p);
             draft.name = await this.visitDefined<TypedTree>(bindingElement.name, p);
             draft.initializer = bindingElement.initializer && await this.visitLeftPadded(bindingElement.initializer, p);
-            draft.variableType = bindingElement.variableType && (await this.visitType(bindingElement.variableType, p) as JavaType.Variable);
+            draft.variableType = bindingElement.variableType && (await this.visitType(bindingElement.variableType, p) as Type.Variable);
         });
     }
 

package/src/json/tree.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {Markers} from "../markers";
-import {SourceFile, Tree, TreeKind} from "../tree";
+import {SourceFile, Tree} from "../tree";
 
 
 export interface Json extends Tree {
@@ -23,7 +23,6 @@ export interface Json extends Tree {
 
 export namespace Json {
     export const Kind = {
-        ...TreeKind,
         Array: "org.openrewrite.json.tree.Json$Array",
         Document: "org.openrewrite.json.tree.Json$Document",
         Empty: "org.openrewrite.json.tree.Json$Empty",

package/src/reference.ts

@@ -44,7 +44,7 @@ export function asRef<T extends {} | undefined>(obj: T): T extends undefined ? u
 }
 
 export function isRef(obj: any): obj is Reference {
-    return obj !== undefined && obj[REFERENCE_KEY] === true;
+    return obj !== undefined && obj !== null && obj[REFERENCE_KEY] === true;
 }
 
 export class ReferenceMap {

package/src/rpc/chrome-profiler.ts

@@ -0,0 +1,373 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as v8 from 'v8';
+import * as inspector from 'inspector';
+
+export class ChromeProfiler {
+    private traceEvents: any[] = [];
+    private memoryInterval?: NodeJS.Timeout;
+    private saveInterval?: NodeJS.Timeout;
+    private session?: inspector.Session;
+    private readonly pid = process.pid;
+    private readonly tid = 1; // Main thread
+    private readonly tracePath: string;
+    private exitHandlersRegistered = false;
+    private startTime: number = 0;
+    private ttsCounter: number = 0;
+    private lastProfileTime: number = 0;
+    private profileNodes = new Map();
+
+    constructor(outputPath?: string) {
+        this.tracePath = outputPath || path.join(process.cwd(), 'chrome-trace.json');
+    }
+
+    async start() {
+        this.startTime = Date.now() * 1000; // Convert to microseconds
+        this.lastProfileTime = this.startTime;
+
+        // Add initial metadata events
+        this.addMetadataEvents();
+
+        // Start V8 Inspector session for CPU profiling
+        this.session = new inspector.Session();
+        this.session.connect();
+
+        // Enable and start CPU profiling
+        await this.enableCpuProfiling();
+
+        // Start collecting memory data
+        this.startMemoryTracking();
+
+        // Save trace periodically and collect CPU profile samples
+        this.saveInterval = setInterval(async () => {
+            await this.collectCpuProfile();
+            this.saveTrace();
+        }, 10000); // Save every 10 seconds
+
+        // Register exit handlers
+        if (!this.exitHandlersRegistered) {
+            this.registerExitHandlers();
+            this.exitHandlersRegistered = true;
+        }
+    }
+
+    private async enableCpuProfiling() {
+        if (!this.session) return;
+
+        // Enable profiler
+        await new Promise<void>((resolve, reject) => {
+            this.session!.post('Profiler.enable', (err) => {
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+
+        // Start sampling
+        await new Promise<void>((resolve, reject) => {
+            this.session!.post('Profiler.start', {
+                // Sample at high frequency for detailed profiling
+                samplingInterval: 100
+            }, (err) => {
+                if (err) reject(err);
+                else resolve();
+            });
+        });
+
+        // Subscribe to console profile events
+        this.session.on('Profiler.consoleProfileStarted', (params: any) => {
+            this.traceEvents.push({
+                cat: 'disabled-by-default-devtools.timeline',
+                name: 'Profile',
+                ph: 'P',
+                id: params.id || '1',
+                pid: this.pid,
+                tid: this.tid,
+                ts: Date.now() * 1000
+            });
+        });
+    }
+
+    private addMetadataEvents() {
+        // Thread name metadata
+        this.traceEvents.push({
+            args: { name: 'CrRendererMain' },
+            cat: '__metadata',
+            name: 'thread_name',
+            ph: 'M',
+            pid: this.pid,
+            tid: this.tid,
+            ts: 0
+        });
+
+        // Process name metadata
+        this.traceEvents.push({
+            args: { name: 'Node.js' },
+            cat: '__metadata',
+            name: 'process_name',
+            ph: 'M',
+            pid: this.pid,
+            tid: 0,
+            ts: 0
+        });
+
+        // TracingStartedInBrowser event - required for Chrome DevTools
+        this.traceEvents.push({
+            args: {
+                data: {
+                    frameTreeNodeId: 1,
+                    frames: [{
+                        frame: '0x1',
+                        name: '',
+                        processId: this.pid,
+                        url: 'node://process'
+                    }],
+                    persistentIds: true
+                }
+            },
+            cat: 'disabled-by-default-devtools.timeline',
+            name: 'TracingStartedInBrowser',
+            ph: 'I',
+            pid: this.pid,
+            s: 't',
+            tid: this.tid,
+            ts: this.startTime,
+            tts: this.ttsCounter++
+        });
+    }
+
+    private startMemoryTracking() {
+        // Collect memory data every 50ms (matching Chrome's frequency)
+        this.memoryInterval = setInterval(() => {
+            const memStats = v8.getHeapStatistics();
+            const timestamp = Date.now() * 1000;
+
+            // UpdateCounters event with correct format
+            this.traceEvents.push({
+                args: {
+                    data: {
+                        jsHeapSizeUsed: memStats.used_heap_size,
+                        jsEventListeners: 0,
+                        documents: 1,
+                        nodes: 0
+                    }
+                },
+                cat: 'disabled-by-default-devtools.timeline',
+                name: 'UpdateCounters',
+                ph: 'I', // Instant event, not Counter
+                pid: this.pid,
+                s: 't', // Required for instant events
+                tid: this.tid,
+                ts: timestamp,
+                tts: this.ttsCounter++
+            });
+        }, 50); // Every 50ms
+    }
+
+    private saveTrace() {
+        const trace = {
+            metadata: {
+                'command-line': process.argv.join(' '),
+                'cpu-brand': 'Node.js V8',
+                'dataOrigin': 'TraceEvents',
+                'highres-ticks': true,
+                'hostname': 'localhost',
+                'num-cpus': require('os').cpus().length,
+                'physical-memory': require('os').totalmem(),
+                'platform': process.platform,
+                'process-uptime': process.uptime(),
+                'product-version': `Node.js ${process.version}`,
+                'protocol-version': '1.0',
+                'source': 'NodeProfiler',
+                'startTime': new Date(this.startTime / 1000).toISOString(),
+                'trace-config': '',
+                'user-agent': `Node.js/${process.version}`,
+                'v8-version': process.versions.v8
+            },
+            traceEvents: this.traceEvents
+        };
+
+        try {
+            fs.writeFileSync(this.tracePath, JSON.stringify(trace, null, 2));
+        } catch (e) {
+            // Ignore write errors
+        }
+    }
+
+    private async collectCpuProfile() {
+        if (!this.session) return;
+
+        try {
+            // Stop current profiling to get samples
+            const profile = await new Promise<any>((resolve, reject) => {
+                this.session!.post('Profiler.stop', (err, params) => {
+                    if (err) reject(err);
+                    else resolve(params.profile);
+                });
+            });
+
+            // Convert CPU profile samples to trace events
+            if (profile && profile.samples) {
+                this.addCpuProfileSamples(profile);
+            }
+
+            // Restart profiling for the next interval
+            await new Promise<void>((resolve, reject) => {
+                this.session!.post('Profiler.start', {
+                    samplingInterval: 100
+                }, (err) => {
+                    if (err) reject(err);
+                    else resolve();
+                });
+            });
+        } catch (e) {
+            // Ignore errors and try to restart
+            try {
+                await new Promise<void>((resolve, reject) => {
+                    this.session!.post('Profiler.start', {
+                        samplingInterval: 100
+                    }, (err) => {
+                        if (err) reject(err);
+                        else resolve();
+                    });
+                });
+            } catch (e2) {
+                // Ignore restart errors
+            }
+        }
+    }
+
+    async stop() {
+        // Clear intervals
+        if (this.memoryInterval) {
+            clearInterval(this.memoryInterval);
+            this.memoryInterval = undefined;
+        }
+        if (this.saveInterval) {
+            clearInterval(this.saveInterval);
+            this.saveInterval = undefined;
+        }
+
+        // Collect final CPU profile
+        await this.collectCpuProfile();
+
+        // Disconnect session
+        if (this.session) {
+            this.session.disconnect();
+            this.session = undefined;
+        }
+
+        // Save final trace
+        this.saveTrace();
+    }
+
+    private addCpuProfileSamples(profile: any) {
+        if (!profile.samples || !profile.timeDeltas || !profile.nodes) return;
+
+        // Use the last profile time as starting point to maintain continuity
+        let currentTime = this.lastProfileTime;
+
+        // Update nodes map with new nodes
+        profile.nodes.forEach((node: any) => {
+            this.profileNodes.set(node.id, node);
+        });
+
+        // Convert samples to trace events with actual function names
+        profile.samples.forEach((nodeId: number, index: number) => {
+            const node = this.profileNodes.get(nodeId);
+            if (!node) return;
+
+            currentTime += (profile.timeDeltas[index] || 0);
+
+            const callFrame = node.callFrame;
+            if (callFrame) {
+                // Clean up function name for display
+                let functionName = callFrame.functionName || '(anonymous)';
+                if (functionName === '' || functionName === '(root)') {
+                    functionName = '(program)';
+                }
+
+                // Extract filename from URL or use a meaningful default
+                let url = callFrame.url || '';
+                let fileName: string;
+
+                if (url) {
+                    // Clean up the URL for display
+                    if (url.startsWith('file://')) {
+                        url = url.substring(7);
+                    }
+                    const parts = url.split('/');
+                    fileName = parts[parts.length - 1] || url;
+
+                    // Special handling for node internals
+                    if (url.startsWith('node:')) {
+                        fileName = url;
+                    }
+                } else {
+                    // No URL - try to provide context from function name
+                    if (functionName === '(garbage collector)') {
+                        fileName = 'v8::gc';
+                    } else if (functionName === '(idle)') {
+                        fileName = 'v8::idle';
+                    } else if (functionName === '(program)') {
+                        fileName = 'main';
+                    } else if (functionName.includes('::')) {
+                        // C++ internal function
+                        fileName = 'native';
+                    } else {
+                        // JavaScript code without source mapping
+                        fileName = 'javascript';
+                    }
+                }
+
+                this.traceEvents.push({
+                    args: {
+                        data: {
+                            columnNumber: callFrame.columnNumber || 0,
+                            frame: `0x${nodeId.toString(16)}`,
+                            functionName: functionName,
+                            lineNumber: callFrame.lineNumber || 0,
+                            scriptId: String(callFrame.scriptId || 0),
+                            url: url || fileName  // Use fileName as URL if no real URL
+                        }
+                    },
+                    cat: 'devtools.timeline',
+                    dur: Math.max(profile.timeDeltas[index] || 1, 1),
+                    name: 'FunctionCall',
+                    ph: 'X',
+                    pid: this.pid,
+                    tid: this.tid,
+                    ts: Math.floor(currentTime),
+                    tts: this.ttsCounter++
+                });
+            }
+        });
+
+        // Update lastProfileTime to maintain continuity for the next batch
+        this.lastProfileTime = currentTime;
+    }
+
+    private registerExitHandlers() {
+        const cleanup = async () => {
+            await this.stop();
+        };
+
+        process.once('beforeExit', cleanup);
+        process.once('SIGINT', cleanup);
+        process.once('SIGTERM', cleanup);
+    }
+}

package/src/rpc/queue.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {emptyMarkers, Marker, Markers, MarkersKind} from "../markers";
+import {emptyMarkers, Markers} from "../markers";
 import {saveTrace, trace} from "./trace";
 import {createDraft, finishDraft} from "immer";
-import {asRef, isRef, Reference, ReferenceMap} from "../reference";
+import {isRef, ReferenceMap} from "../reference";
 import {Writable} from "node:stream";
 
 /**
@@ -106,16 +106,6 @@ export class RpcSendQueue {
         this.q.push(d);
     }
 
-    sendMarkers<T extends { markers: Markers }>(parent: T, markersFn: (parent: T) => any): Promise<void> {
-        return this.getAndSend(parent, t2 => asRef(markersFn(t2)), async (markersRef: Markers & Reference) => {
-            await this.getAndSend(markersRef, m => m.id);
-            await this.getAndSendList(markersRef,
-                (m) => m.markers,
-                (marker: Marker) => marker.id
-            );
-        });
-    }
-
     getAndSend<T, U>(parent: T,
                      value: (parent: T) => U | undefined,
                      onChange?: (value: U) => Promise<any>): Promise<void> {
@@ -298,6 +288,12 @@ export class RpcReceiveQueue {
                         before = message.valueType === undefined ?
                             message.value :
                             this.newObj(message.valueType);
+                        if (ref !== undefined) {
+                            // For an object like JavaType that we will mutate in place rather than using
+                            // immutable updates because of its cyclic nature, the before instance will ultimately
+                            // be the same as the after instance below.
+                            this.refs.set(ref, before);
+                        }
                     }
                 // Intentional fall-through...
                 case RpcObjectState.CHANGE:

package/src/rpc/request/parse.ts

@@ -16,7 +16,7 @@
 import * as rpc from "vscode-jsonrpc/node";
 import {ExecutionContext} from "../../execution";
 import {UUID} from "node:crypto";
-import {ParserInput, Parsers} from "../../parser";
+import {Parser, ParserInput, Parsers} from "../../parser";
 import {randomId} from "../../uuid";
 import {produce} from "immer";
 import {SourceFile} from "../../tree";

package/src/rpc/rewrite-rpc.ts

@@ -115,7 +115,7 @@ export class RewriteRpc {
             );
         }, this.options.traceGetObjectInput);
 
-        const remoteObject = await q.receive<P>(this.localObjects.get(id));
+        const remoteObject = await q.receive<P>(localObject);
 
         const eof = (await q.take());
         if (eof.state !== RpcObjectState.END_OF_OBJECT) {
@@ -152,7 +152,8 @@ export class RewriteRpc {
     }
 
     async print(tree: SourceFile): Promise<string>;
-    async print<T extends Tree>(tree: T, cursor?: Cursor): Promise<string> {
+    async print(tree: Tree, cursor: Cursor): Promise<string>;
+    async print(tree: Tree, cursor?: Cursor): Promise<string> {
         if (!cursor && !isSourceFile(tree)) {
             throw new Error("Cursor is required for non-SourceFile trees");
         }

package/src/rpc/server.ts

@@ -20,6 +20,7 @@ import {RewriteRpc} from "./rewrite-rpc";
 import * as fs from "fs";
 import {Command} from 'commander';
 import {dir} from 'tmp-promise';
+import {ChromeProfiler} from './chrome-profiler';
 
 // Include all languages you want this server to support.
 import "../text";
@@ -28,7 +29,7 @@ import "../java";
 import "../javascript";
 
 // Not possible to set the stack size when executing from npx for security reasons
-require('v8').setFlagsFromString('--stack-size=4000');
+require('v8').setFlagsFromString('--stack-size=8000');
 
 interface ProgramOptions {
     logFile?: string;
@@ -37,6 +38,7 @@ interface ProgramOptions {
     traceGetObjectOutput?: boolean;
     traceGetObjectInput?: boolean;
     recipeInstallDir?: string;
+    profile?: boolean;
 }
 
 async function main() {
@@ -49,10 +51,18 @@ async function main() {
         .option('--trace-get-object-output', 'enable `GetObject` output tracing')
         .option('--trace-get-object-input', 'enable `GetObject` input tracing')
         .option('--recipe-install-dir <install_dir>', 'Recipe installation directory (default is a temporary directory)')
+        .option('--profile', 'enable profiling')
         .parse();
 
     const options = program.opts() as ProgramOptions;
 
+    // Chrome profiling
+    let profiler: ChromeProfiler | undefined;
+    if (options.profile) {
+        profiler = new ChromeProfiler();
+        profiler.start().catch(console.error);
+    }
+
     let recipeInstallDir: string;
     if (!options.recipeInstallDir) {
         let recipeCleanup: () => Promise<void>;
@@ -65,6 +75,9 @@ async function main() {
 
         // Register cleanup on exit
         process.on('SIGINT', async () => {
+            if (profiler) {
+                await profiler.stop();
+            }
             if (recipeCleanup) {
                 await recipeCleanup();
             }
@@ -72,6 +85,9 @@ async function main() {
         });
 
         process.on('SIGTERM', async () => {
+            if (profiler) {
+                await profiler.stop();
+            }
             if (recipeCleanup) {
                 await recipeCleanup();
             }
@@ -81,6 +97,19 @@ async function main() {
         recipeInstallDir = await setupRecipeDir();
     } else {
         recipeInstallDir = options.recipeInstallDir;
+
+        // Register cleanup for profiler when no recipe cleanup is needed
+        if (profiler) {
+            process.on('SIGINT', async () => {
+                await profiler.stop();
+                process.exit(0);
+            });
+
+            process.on('SIGTERM', async () => {
+                await profiler.stop();
+                process.exit(0);
+            });
+        }
     }
 
     const log = options.logFile ? fs.createWriteStream(options.logFile, {flags: 'a'}) : undefined;

package/src/test/rewrite-test.ts

@@ -61,8 +61,20 @@ export class RecipeSpec {
         this.dataTableAssertions[name] = allRows;
     }
 
-    async rewriteRun(...sourceSpecs: SourceSpec<any>[]): Promise<void> {
-        const specsByKind = sourceSpecs.reduce((groups, spec) => {
+    async rewriteRun(...sourceSpecs: (SourceSpec<any> | Generator<SourceSpec<any>, void, unknown>)[]): Promise<void> {
+        // Flatten generators into a list of sourceSpecs
+        const flattenedSpecs: SourceSpec<any>[] = [];
+        for (const specOrGenerator of sourceSpecs) {
+            if (specOrGenerator && typeof (specOrGenerator as any).next === 'function') {
+                for (const spec of specOrGenerator as Generator<SourceSpec<any>, void, unknown>) {
+                    flattenedSpecs.push(spec);
+                }
+            } else {
+                flattenedSpecs.push(specOrGenerator as SourceSpec<any>);
+            }
+        }
+
+        const specsByKind = flattenedSpecs.reduce((groups, spec) => {
             const kind = spec.kind;
             if (!groups[kind]) {
                 groups[kind] = [];
@@ -179,7 +191,11 @@ export class RecipeSpec {
             const b = spec.beforeRecipe ? spec.beforeRecipe(sourceFile) : sourceFile;
             if (b !== undefined) {
                 if (b instanceof Promise) {
-                    return [spec, await b];
+                    const mapped = await b;
+                    if (mapped === undefined) {
+                        throw new Error("Expected beforeRecipe to return a SourceFile, but got undefined. Did you forget a return statement?");
+                    }
+                    return [spec, mapped];
                 }
                 return [spec, b as SourceFile];
             }

package/src/text/tree.ts

@@ -23,7 +23,6 @@ export interface PlainText extends SourceFile {
 
 export namespace PlainText {
     export const Kind = {
-        ...TreeKind,
         PlainText: "org.openrewrite.text.PlainText",
         Snippet: "org.openrewrite.text.PlainText$Snippet"
     } as const

package/src/tree.ts

@@ -77,6 +77,21 @@ export class Cursor {
         return path;
     }
 
+    parentTree(level: number = 1): Cursor | undefined {
+        let c: Cursor | undefined = this.parent;
+        let treeCount = 0;
+        while (c) {
+            if (isTree(c.value)) {
+                treeCount++;
+                if (treeCount === level) {
+                    return c;
+                }
+            }
+            c = c.parent;
+        }
+        return undefined;
+    }
+
     firstEnclosing<T>(match: (value: any) => value is T): T | undefined {
         let c: Cursor | undefined = this;
         while (c) {