@openrewrite/rewrite 8.62.1 → 8.62.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrewrite/rewrite",
-  "version": "8.62.1",
+  "version": "8.62.3",
   "license": "Moderne Source Available License",
   "description": "OpenRewrite JavaScript.",
   "homepage": "https://github.com/openrewrite/rewrite",

package/src/javascript/type-mapping.ts

@@ -170,16 +170,63 @@ export class JavaScriptTypeMapping {
             if (ts.isPropertyAccessExpression(node.expression)) {
                 methodName = node.expression.name.getText();
                 const exprType = this.checker.getTypeAtLocation(node.expression.expression);
-                declaringType = this.getType(exprType) as Type.FullyQualified;
+                const mappedType = this.getType(exprType);
+
+                // For string methods like 'hello'.split(), ensure we have a proper declaring type
+                if (!mappedType || mappedType.kind !== Type.Kind.Class) {
+                    // If the expression type is a primitive string, use lib.String as declaring type
+                    const typeString = this.checker.typeToString(exprType);
+                    if (typeString === 'string' || exprType.flags & ts.TypeFlags.String || exprType.flags & ts.TypeFlags.StringLiteral) {
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            fullyQualifiedName: 'lib.String'
+                        } as Type.FullyQualified;
+                    } else if (typeString === 'number' || exprType.flags & ts.TypeFlags.Number || exprType.flags & ts.TypeFlags.NumberLiteral) {
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            fullyQualifiedName: 'lib.Number'
+                        } as Type.FullyQualified;
+                    } else {
+                        // Fallback for other primitive types or unknown
+                        declaringType = Type.unknownType as Type.FullyQualified;
+                    }
+                } else {
+                    declaringType = mappedType as Type.FullyQualified;
+                }
             } else if (ts.isIdentifier(node.expression)) {
                 methodName = node.expression.getText();
-                // For standalone functions, use the symbol's parent or module
-                const parent = (symbol as any).parent;
-                if (parent) {
-                    const parentType = this.checker.getDeclaredTypeOfSymbol(parent);
-                    declaringType = this.getType(parentType) as Type.FullyQualified;
+                // For standalone functions, we need to determine the appropriate declaring type
+                const exprType = this.checker.getTypeAtLocation(node.expression);
+                const funcType = this.getType(exprType);
+
+                if (funcType && funcType.kind === Type.Kind.Class) {
+                    const fqn = (funcType as Type.Class).fullyQualifiedName;
+                    const lastDot = fqn.lastIndexOf('.');
+
+                    if (lastDot > 0) {
+                        // For functions from modules, use the module part as declaring type
+                        // Examples:
+                        // - "node.assert" -> declaring type: "node"
+                        // - "@types/lodash.map" -> declaring type: "@types/lodash"
+                        // - "@types/express.express" -> declaring type: "@types/express"
+                        declaringType = {
+                            kind: Type.Kind.Class,
+                            fullyQualifiedName: fqn.substring(0, lastDot)
+                        } as Type.FullyQualified;
+                    } else {
+                        // No dots in the name - the type IS the module itself
+                        // This handles single-name modules like "axios", "lodash" etc.
+                        declaringType = funcType as Type.FullyQualified;
+                    }
                 } else {
-                    declaringType = Type.unknownType as Type.FullyQualified;
+                    // Try to use the symbol's parent or module
+                    const parent = (symbol as any).parent;
+                    if (parent) {
+                        const parentType = this.checker.getDeclaredTypeOfSymbol(parent);
+                        declaringType = this.getType(parentType) as Type.FullyQualified;
+                    } else {
+                        declaringType = Type.unknownType as Type.FullyQualified;
+                    }
                 }
             } else {
                 methodName = symbol.getName();
@@ -330,6 +377,30 @@ export class JavaScriptTypeMapping {
         if (sourceFile.isDeclarationFile || fileName.includes("node_modules")) {
             const packageName = this.extractPackageName(fileName);
             if (packageName) {
+                // Special handling for @types/node - these are Node.js built-in modules
+                // and should be mapped to "node.*" instead of "@types/node.*"
+                if (packageName === "@types/node") {
+                    // Extract the module name from the file path
+                    // e.g., /node_modules/@types/node/assert.d.ts -> assert
+                    // e.g., /node_modules/@types/node/fs/promises.d.ts -> fs/promises
+                    const nodeMatch = fileName.match(/node_modules\/@types\/node\/([^.]+)\.d\.ts/);
+                    if (nodeMatch) {
+                        const modulePath = nodeMatch[1];
+                        // For default exports from Node modules, we want the module to be the "class"
+                        // But we still need to include the type name for proper identification
+                        if (typeName === "default" || typeName === modulePath) {
+                            // This is likely the default export, just use the module name
+                            return `node.${modulePath}`;
+                        }
+                        // For named exports, include both module and type name
+                        if (modulePath.includes('/')) {
+                            return `node.${modulePath.replace(/\//g, '.')}.${typeName}`;
+                        }
+                        return `node.${modulePath}.${typeName}`;
+                    }
+                    // Fallback for @types/node types that don't match the pattern
+                    return `node.${typeName}`;
+                }
                 return `${packageName}.${typeName}`;
             }
         }
@@ -392,8 +463,22 @@ export class JavaScriptTypeMapping {
                 const typesMatch = fileName.match(/node_modules\/@types\/([^/]+)/);
                 if (typesMatch) {
                     const packageName = typesMatch[1];
-                    // Replace the module specifier part with @types/package
-                    fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `@types/${packageName}.`);
+                    // Special handling for @types/node - use "node" prefix instead
+                    if (packageName === "node") {
+                        // Extract the module name from the file path if possible
+                        const nodeMatch = fileName.match(/node_modules\/@types\/node\/([^.]+)\.d\.ts/);
+                        if (nodeMatch) {
+                            const modulePath = nodeMatch[1];
+                            // Replace the module specifier with node.module
+                            fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `node.${modulePath}.`);
+                        } else {
+                            // Fallback: just use "node" prefix
+                            fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `node.`);
+                        }
+                    } else {
+                        // Replace the module specifier part with @types/package
+                        fullyQualifiedName = fullyQualifiedName.replace(/^[^.]+\./, `@types/${packageName}.`);
+                    }
                 }
             }
         }

package/src/print.ts

@@ -143,11 +143,13 @@ export class TreePrinters {
      * @param target Helps to determine what kind of language we are dealing with when
      * printing a subtree whose LST type is shared between multiple languages in a language family.
      */
-    static printer(target: Cursor | SourceFile): TreePrinter {
-        const sourceFileKind = (isSourceFile(target) ?
+    static printer(target: Cursor | SourceFile | string): TreePrinter {
+        const sourceFileKind = typeof target === 'string' ?
+            target :
+            (isSourceFile(target) ?
                 target as SourceFile :
                 target.firstEnclosing(isSourceFile)
-        )!.kind
+            )!.kind
 
         if (!this._registry.has(sourceFileKind)) {
             throw new Error(`No printer registered for ${sourceFileKind}`)
@@ -160,6 +162,6 @@ export class TreePrinters {
     }
 }
 
-export function printer(target: Cursor | SourceFile): TreePrinter {
+export function printer(target: Cursor | SourceFile | string): TreePrinter {
     return TreePrinters.printer(target);
 }

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/request/print.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import * as rpc from "vscode-jsonrpc/node";
-import {Cursor, isSourceFile, Tree} from "../../tree";
+import {isSourceFile, Tree} from "../../tree";
 import {MarkerPrinter as PrintMarkerPrinter, printer, PrintOutputCapture} from "../../print";
 import {UUID} from "../../uuid";
 
@@ -25,20 +25,18 @@ export const enum MarkerPrinter {
 }
 
 export class Print {
-    constructor(private readonly treeId: UUID, private readonly cursor?: string[], readonly markerPrinter: MarkerPrinter = MarkerPrinter.DEFAULT) {
+    constructor(private readonly treeId: UUID, private readonly sourceFileType: string, readonly markerPrinter: MarkerPrinter = MarkerPrinter.DEFAULT) {
     }
 
     static handle(connection: rpc.MessageConnection,
-                  getObject: (id: string) => any,
-                  getCursor: (cursorIds: string[] | undefined) => Promise<Cursor>): void {
+                  getObject: (id: string) => any): void {
         connection.onRequest(new rpc.RequestType<Print, string, Error>("Print"), async request => {
             const tree: Tree = await getObject(request.treeId.toString());
             const out = new PrintOutputCapture(PrintMarkerPrinter[request.markerPrinter]);
             if (isSourceFile(tree)) {
                 return await printer(tree).print(tree, out);
             } else {
-                const cursor = await getCursor(request.cursor);
-                return await printer(cursor).print(tree, out);
+                return await printer(request.sourceFileType).print(tree, out);
             }
         });
     }

package/src/rpc/rewrite-rpc.ts

@@ -82,7 +82,7 @@ export class RewriteRpc {
         GetLanguages.handle(this.connection);
         PrepareRecipe.handle(this.connection, registry, preparedRecipes);
         Parse.handle(this.connection, this.localObjects);
-        Print.handle(this.connection, getObject, getCursor);
+        Print.handle(this.connection, getObject);
         InstallRecipes.handle(this.connection, options.recipeInstallDir ?? ".rewrite", registry, options.logger);
 
         this.connection.listen();
@@ -160,7 +160,8 @@ export class RewriteRpc {
         this.localObjects.set(tree.id.toString(), tree);
         return await this.connection.sendRequest(
             new rpc.RequestType<Print, string, Error>("Print"),
-            new Print(tree.id, this.getCursorIds(cursor))
+            new Print(tree.id, isSourceFile(tree) ? tree.kind :
+                cursor!.firstEnclosing(t => isSourceFile(t))!.kind)
         );
     }
 

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";
@@ -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;