@openrewrite/recipes-nodejs 0.52.0-20261009-102010 → 0.52.1

package/src/migrate/source-map-support/enable-source-maps-at-launch.ts

@@ -11,7 +11,14 @@ import {getMemberKeyName, isLiteral, isMember, isObject, Json, JsonVisitor} from
 import {PlainText} from "@openrewrite/rewrite/text";
 import {dirOf, isPackageJson} from "../package-json-support";
 import {addSourceMapsFlag, launchesNode, REGISTER_MODULES, shebangWithSourceMapsFlag} from "./register-flag";
-import {isSourceMapSupport, SourceMapSupportVisitor, sourcePathOf, stringLiteral} from "./source-map-support-support";
+import {
+    hasOnlyNativeOptions,
+    isSourceMapSupport,
+    SourceMapSupportVisitor,
+    sourcePathOf,
+    stringLiteral,
+    withoutStatements
+} from "./source-map-support-support";
 
 interface Accumulator {
     /** Files holding an `install()` or `register` entry point the in-place rewrite declines. */
@@ -69,10 +76,16 @@ export class EnableSourceMapsAtLaunch extends ScanningRecipe<Accumulator> {
             }
 
             protected override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
-                if (this.isInstall(method) || isRegisterRequire(method)) this.recordIfDeclined();
+                if (this.isNativeInstall(method) || isRegisterRequire(method)) this.recordIfDeclined();
                 return super.visitMethodInvocation(method, p);
             }
 
+            /** An `install()` the launch flag can stand in for; the API rewrite takes one with other options. */
+            private isNativeInstall(m: J.MethodInvocation): boolean {
+                const args = m.arguments.elements.map(a => a.element).filter(a => a.kind !== J.Kind.Empty);
+                return this.isInstall(m) && args.length <= 1 && hasOnlyNativeOptions(args[0]);
+            }
+
             /** Only a site the in-place rewrite turns down is this recipe's business. */
             private recordIfDeclined(): void {
                 if (this.mapsEverythingLoaded()) return;
@@ -218,29 +231,6 @@ export class EnableSourceMapsAtLaunch extends ScanningRecipe<Accumulator> {
     }
 }
 
-/**
- * Drops the statements `remove` selects, handing the first of a removed run its successor's place
- * in the layout, so the blank line that separated it from what came before isn't left behind. Only
- * the whitespace moves: a comment sits in the prefix of the statement it documents, so taking the
- * successor's prefix wholesale would delete the comment that belongs to it.
- */
-function withoutStatements(statements: J.RightPadded<any>[], remove: (s: J) => boolean): J.RightPadded<any>[] {
-    const kept: J.RightPadded<any>[] = [];
-    let pendingWhitespace: string | undefined;
-    for (const padded of statements) {
-        if (remove(padded.element)) {
-            pendingWhitespace ??= (padded.element.prefix as J.Space).whitespace;
-            continue;
-        }
-        kept.push(pendingWhitespace === undefined ? padded : {
-            ...padded,
-            element: {...padded.element, prefix: {...padded.element.prefix, whitespace: pendingWhitespace}}
-        });
-        pendingWhitespace = undefined;
-    }
-    return kept;
-}
-
 /** The innermost package a repo-relative path belongs to, of those the scan saw. */
 function enclosingPackage(path: string, packageDirs: string[]): string {
     return packageOf(path, packageDirs) ?? '';
@@ -265,7 +255,8 @@ function isRedundantEntryPoint(statement: J): boolean {
     if (call?.kind !== J.Kind.MethodInvocation) return false;
     const m = call as J.MethodInvocation;
     if (isRegisterRequire(m)) return true;
-    if (m.name.simpleName !== 'install') return false;
+    const args = m.arguments.elements.map(a => a.element).filter(a => a.kind !== J.Kind.Empty);
+    if (m.name.simpleName !== 'install' || args.length > 1 || !hasOnlyNativeOptions(args[0])) return false;
     const select = m.select?.element;
     return select?.kind === J.Kind.MethodInvocation
         ? isSourceMapSupport(requiredModuleOf(select as J.MethodInvocation))

package/src/migrate/source-map-support/find-source-map-support-manual-migrations.ts

@@ -10,8 +10,10 @@ import {JS} from "@openrewrite/rewrite/javascript";
 import {getMemberKeyName, isLiteral, isMember, isObject, Json, JsonVisitor} from "@openrewrite/rewrite/json";
 import {REGISTER_MODULES, replaceRegisterFlag} from "./register-flag";
 import {
+    DECLARING_KINDS,
     isModuleScoped,
     isSourceMapSupport,
+    isWriteTarget,
     MODULES,
     NON_INSTALL_MEMBERS,
     nonNativeOption,
@@ -25,12 +27,6 @@ import {
 const MOCK_OWNERS = new Set(['vi', 'jest']);
 const MOCK_METHODS = new Set(['mock', 'doMock', 'unmock', 'unstable_mockModule']);
 
-/** Trees that hold an identifier as a declaration or import rather than a use of it. */
-const DECLARING_KINDS = new Set<string>([
-    JS.Kind.Import, JS.Kind.ImportClause, JS.Kind.ImportSpecifier, JS.Kind.Alias, JS.Kind.NamedImports,
-    JS.Kind.ExportSpecifier, JS.Kind.BindingElement, JS.Kind.ObjectBindingPattern,
-]);
-
 function isSourceMapSupportSpecifier(e: J | undefined): boolean {
     return isSourceMapSupport(stringLiteral(e));
 }
@@ -48,6 +44,9 @@ function isMockCall(m: J.MethodInvocation): boolean {
     return !!select && isIdentifier(select) && MOCK_OWNERS.has(select.simpleName) && MOCK_METHODS.has(m.name.simpleName);
 }
 
+/** Where a specifier string is a value of its own, not the argument of a `require`, `import` or mock. */
+const HELD_AS_DATA = new Set<string>([J.Kind.NewArray, JS.Kind.PropertyAssignment, J.Kind.NamedVariable, J.Kind.Assignment]);
+
 /** Sections of a `package.json` whose string values are shell commands. */
 const SCRIPT_SECTIONS = new Set(['scripts']);
 
@@ -56,8 +55,9 @@ export class FindSourceMapSupportManualMigrations extends Recipe {
     readonly displayName = "Find source-map-support usages that need manual migration";
     readonly description = "Marks every source-map-support usage the automated migration leaves in place — an " +
         "`install()` or `register` entry point that would only map part of the process, options Node has no " +
-        "equivalent for (`retrieveSourceMap`, `retrieveFile`, `environment: 'browser'`), the API beyond `install` " +
-        "(`wrapCallSite`, `mapSourcePosition`, ...), bundler banner strings, `package.json` scripts whose command " +
+        "equivalent for (`retrieveSourceMap`, `retrieveFile`, `environment: 'browser'`) and the API beyond `install` " +
+        "(`wrapCallSite`, `mapSourcePosition`, ...) where no replacement could be written, bundler banner strings, " +
+        "`package.json` scripts whose command " +
         "doesn't take Node's flags, type imports, re-exports, dynamic imports and test mocks — and records each with " +
         "a suggested replacement in the `SourceMapSupportManualMigrationSteps` data table.";
     readonly tags = ["source-map-support"];
@@ -199,12 +199,28 @@ export class FindSourceMapSupportManualMigrations extends Recipe {
                 return this.canCallProcess() ? REASONS.partialMapping : REASONS.localProcess;
             }
 
+            /** A member the rewrite left in place: assigned to, or read through a binding it couldn't replace. */
+            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: ExecutionContext): Promise<J | undefined> {
+                const f = await super.visitFieldAccess(fieldAccess, p) as J.FieldAccess;
+                const target = f.target;
+                if (!isIdentifier(target) || !this.isWholeModule(target.simpleName)) return f;
+                const member = f.name.element.simpleName;
+                const reason = isWriteTarget(this.cursor) ? REASONS.assigned(member)
+                    : this.inTypePosition() ? REASONS.type
+                        : NON_INSTALL_MEMBERS.has(member) ? REASONS.member(member) : REASONS.value;
+                return this.report(f, `${target.simpleName}.${member}`, reason, p);
+            }
+
             /** A string naming the module that isn't a specifier: code destined for a bundle, as a webpack banner is. */
             override async visitLiteral(literal: J.Literal, p: ExecutionContext): Promise<J | undefined> {
                 const l = await super.visitLiteral(literal, p) as J.Literal;
                 if (typeof l.value !== 'string' || !l.value.includes('source-map-support')) return l;
                 // A specifier stands alone; a banner carries surrounding code.
-                if (isSourceMapSupport(l.value)) return l;
+                if (isSourceMapSupport(l.value)) {
+                    // Held as data rather than loaded, as a `--require` argument for a child process is.
+                    const parent = this.cursor.parentTree()?.value as J | undefined;
+                    return parent && HELD_AS_DATA.has(parent.kind) ? this.report(l, l.value, REASONS.specifierString, p) : l;
+                }
                 return this.report(l, 'banner', REASONS.bannerString, p);
             }
 

package/src/migrate/source-map-support/migrate-source-map-support-to-native.ts

@@ -19,10 +19,13 @@ export class MigrateSourceMapSupportToNative extends Recipe {
         "— in an ES module every `import` is evaluated before any statement runs — the flag goes on the " +
         "launcher instead, in the package's `bin` shebang or a `node` script, and the entry point is removed " +
         "as redundant. " +
-        "Uses with no native equivalent (custom `retrieveSourceMap`, browser bundles, webpack banners) are left in place, and " +
-        "the dependency is removed from each `package.json` that declares it, with the lock file updated to match. " +
-        "Everything left in place is recorded in the `SourceMapSupportManualMigrationSteps` data table with a " +
-        "suggested replacement, and has to be migrated before building, since the dependency is removed regardless.";
+        "What Node has no equivalent for — `install()` with a custom `retrieveSourceMap` or `retrieveFile`, and " +
+        "`wrapCallSite`, `getErrorSource`, `mapSourcePosition`, `retrieveSourceMap` and `resetRetrieveHandlers` — is " +
+        "written into the file that uses it, on Node's own `SourceMap`, and an `install()` configured for a browser is " +
+        "removed. The dependency is removed from each `package.json` that declares it, with the lock file updated to " +
+        "match. Anything left in place, such as a webpack banner, is recorded in the " +
+        "`SourceMapSupportManualMigrationSteps` data table with a suggested replacement, and has to be migrated " +
+        "before building, since the dependency is removed regardless.";
     readonly tags = ["source-map-support"];
 
     async recipeList(): Promise<Recipe[]> {

package/src/migrate/source-map-support/replace-source-map-support-api.ts

@@ -0,0 +1,281 @@
+/*
+ * Copyright 2026 the original author or authors.
+ *
+ * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
+ */
+
+import {Cursor, emptyMarkers, ExecutionContext, findMarker, randomId, Recipe, TreePrinters, TreeVisitor} from "@openrewrite/rewrite";
+import {emptySpace, isIdentifier, J} from "@openrewrite/rewrite/java";
+import {
+    autoFormat,
+    deconflict,
+    isReference,
+    JavaScriptParser,
+    JavaScriptVisitor,
+    JS,
+    maybeUnbind,
+    namesDeclaredIn,
+    namesReferencedWithin,
+    referencesOf,
+    StyleKind
+} from "@openrewrite/rewrite/javascript";
+import {detectCodeStyle} from "../code-style";
+import {bindingsOf, requiredModule, stringLiteral} from "../module-bindings";
+import {
+    ApiBuiltin,
+    ApiDeclaration,
+    apiSource,
+    builtinsFor,
+    declarationsFor,
+    TYPE_MEMBERS,
+    VALUE_MEMBERS
+} from "./source-map-support-api-source";
+import {
+    hasOnlyNativeOptions,
+    isBrowserInstall,
+    isModuleScoped,
+    isWriteTarget,
+    MODULES,
+    SourceMapSupportVisitor,
+    withoutStatements
+} from "./source-map-support-support";
+
+/** A name no file uses, which a declaration carries until the imports it replaces are gone. */
+function placeholder(declaration: ApiDeclaration): string {
+    return `__sourceMapSupport$${declaration}`;
+}
+
+/** What `import type {...}` and `import {type ...}` of source-map-support bind, by local name. */
+function typeBindingsOf(cu: JS.CompilationUnit): Map<string, string> {
+    const bindings = new Map<string, string>();
+    for (const padded of cu.statements) {
+        if (padded.element?.kind !== JS.Kind.Import) continue;
+        const imp = padded.element as JS.Import;
+        const clause = imp.importClause;
+        const named = clause?.namedBindings;
+        if (!MODULES.has(stringLiteral(imp.moduleSpecifier?.element) ?? '') || named?.kind !== JS.Kind.NamedImports) continue;
+        for (const el of (named as JS.NamedImports).elements.elements) {
+            const spec = el.element as JS.ImportSpecifier;
+            if (spec.kind !== JS.Kind.ImportSpecifier || !(clause!.typeOnly || spec.importType?.element)) continue;
+            if (isIdentifier(spec.specifier)) {
+                bindings.set(spec.specifier.simpleName, spec.specifier.simpleName);
+            } else if (spec.specifier.kind === JS.Kind.Alias && isIdentifier((spec.specifier as JS.Alias).alias)) {
+                const alias = spec.specifier as JS.Alias;
+                bindings.set((alias.alias as J.Identifier).simpleName, alias.propertyName.element.simpleName);
+            }
+        }
+    }
+    return bindings;
+}
+
+function identifier(prefix: J.Space, simpleName: string): J.Identifier {
+    return {kind: J.Kind.Identifier, id: randomId(), prefix, markers: emptyMarkers, annotations: [], simpleName} as unknown as J.Identifier;
+}
+
+/** Gives each declaration its final name, once the imports that held those names have been removed. */
+class NameDeclarations extends JavaScriptVisitor<ExecutionContext> {
+    constructor(private readonly names: ReadonlyMap<string, string>) {
+        super();
+    }
+
+    override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+        const id = await super.visitIdentifier(identifier, p) as J.Identifier;
+        const name = this.names.get(id.simpleName);
+        return name ? {...id, simpleName: name} as J.Identifier : id;
+    }
+}
+
+export class ReplaceSourceMapSupportApi extends Recipe {
+    readonly name = "org.openrewrite.node.migrate.source-map-support.replace-source-map-support-api";
+    readonly displayName = "Replace source-map-support's API with functions written into the file";
+    readonly description = "Writes the part of source-map-support that Node has no equivalent for into each file " +
+        "that uses it, built on Node's own source map decoder (`node:module`'s `SourceMap`): `install()` with a " +
+        "custom `retrieveSourceMap` or `retrieveFile`, or with options that can't be read statically, becomes " +
+        "`installSourceMapSupport()`, and `wrapCallSite`, `getErrorSource`, `mapSourcePosition`, `retrieveSourceMap` " +
+        "and `resetRetrieveHandlers` become functions of the same name, along with the types they take from " +
+        "`@types/source-map-support`. Only the functions a file calls, and what they depend on, are written, " +
+        "after its other statements. An `install()` configured for a browser is removed: browsers map stack " +
+        "traces in their developer tools, and Node's source maps don't run there.";
+    readonly tags = ["source-map-support"];
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends SourceMapSupportVisitor<ExecutionContext> {
+            /** Declarations the rewritten sites name. */
+            private needed = new Set<ApiDeclaration>();
+            /** The declaration each reference to a named binding of the module is renamed to, by identifier id. */
+            private renames = new Map<string, ApiDeclaration>();
+            /** Named bindings whose every reference is renamed, so their names come free once they are unbound. */
+            private released = new Set<string>();
+            /** Members whose named bindings are renamed, which are unbound once unused. */
+            private members = new Set<string>();
+            /** Browser `install()` statements, which are removed. */
+            private browserInstalls = new Set<string>();
+
+            protected override async visitJsCompilationUnit(cu: JS.CompilationUnit, p: ExecutionContext): Promise<J | undefined> {
+                if (/\.d\.[cm]?ts$/.test(cu.sourcePath)) return cu;
+                this.needed = new Set();
+                this.released = new Set();
+                this.members = new Set();
+                this.browserInstalls = new Set();
+                this.renames = this.planRenames(cu);
+                this.resetBindings();
+
+                const visited = await super.visitJsCompilationUnit(cu, p) as JS.CompilationUnit;
+                if (this.needed.size === 0 && this.browserInstalls.size === 0) return cu;
+
+                const typeScript = /\.[cm]?tsx?$/.test(cu.sourcePath);
+                const declarations = declarationsFor(this.needed, typeScript);
+                const builtins = new Map<ApiBuiltin, string>();
+                for (const builtin of builtinsFor(declarations)) {
+                    const [module, member] = builtin.split('#') as [string, string];
+                    const local = this.bindNode(module, member);
+                    // A file that can't import Node's builtins keeps source-map-support, for the finder to report.
+                    if (!local) return cu;
+                    builtins.set(builtin, local);
+                }
+
+                let result = await this.insertPendingRequires(cu, visited);
+                if (this.browserInstalls.size > 0) {
+                    result = {...result, statements: withoutStatements(result.statements, s => this.browserInstalls.has(statementCall(s)?.id ?? ''))};
+                }
+                const names = new Map<string, string>();
+                if (declarations.length > 0) {
+                    result = await this.withDeclarations(cu, result, declarations, builtins, names, typeScript, p);
+                }
+                maybeUnbind(this, {module: 'source-map-support'});
+                for (const member of this.members) maybeUnbind(this, {module: 'source-map-support', member});
+                // Last, so the imports that held these names are already gone.
+                if (names.size > 0) this.afterVisit.push(new NameDeclarations(names));
+                return result;
+            }
+
+            /**
+             * Where each named binding of a member the migration writes is referenced. A binding with a
+             * reference that can't be renamed, as a shorthand property spells its key with it, is left alone.
+             */
+            private planRenames(cu: JS.CompilationUnit): Map<string, ApiDeclaration> {
+                const renames = new Map<string, ApiDeclaration>();
+                for (const [local, member] of [...bindingsOf(cu, MODULES), ...typeBindingsOf(cu)]) {
+                    // `install` is rewritten only at the calls whose options need it.
+                    if (member === undefined || member === 'install') continue;
+                    const declaration = VALUE_MEMBERS.get(member) ?? TYPE_MEMBERS.get(member);
+                    if (!declaration) continue;
+                    const references = referencesOf(this.cursor, local).filter(r => !r.declares);
+                    if (references.some(r => !isReference(r.cursor, r.identifier))) continue;
+                    for (const r of references) renames.set(r.identifier.id, declaration);
+                    this.released.add(local);
+                    this.members.add(member);
+                }
+                return renames;
+            }
+
+            /** Appends `declarations` under their placeholders, recording in `names` what each is finally called. */
+            private async withDeclarations(original: JS.CompilationUnit, cu: JS.CompilationUnit, declarations: ApiDeclaration[],
+                                           builtins: Map<ApiBuiltin, string>, names: Map<string, string>, typeScript: boolean,
+                                           p: ExecutionContext): Promise<JS.CompilationUnit> {
+                // A top-level declaration clashes with any name the file declares, and captures a global it reads.
+                const declared = namesDeclaredIn(original);
+                const read = namesReferencedWithin(original);
+                const builtinLocals = new Set(builtins.values());
+                for (const declaration of declarations) {
+                    const taken = new Set(names.values());
+                    names.set(placeholder(declaration), deconflict(declaration, name =>
+                        ((declared.has(name) || read.has(name)) && !this.released.has(name)) || builtinLocals.has(name) || taken.has(name)));
+                }
+                const source = apiSource(declarations, {
+                    names: placeholder,
+                    builtins: builtin => builtins.get(builtin)!,
+                    typeScript,
+                    style: detectCodeStyle(await TreePrinters.print(original)),
+                });
+                // Parsed rather than templated, so the code keeps the layout written for this file's style.
+                const parsed = await new JavaScriptParser().parseOnly({
+                    text: source, sourcePath: typeScript ? 'source-map-support.ts' : 'source-map-support.js'
+                }) as JS.CompilationUnit;
+                // The call sites already name the declarations, so a source that doesn't parse can't be skipped.
+                if (parsed.kind !== JS.Kind.CompilationUnit) throw new Error(`The source-map-support API written for ${original.sourcePath} does not parse`);
+                // Where the project formats with Prettier, its own configuration lays the declarations out.
+                const prettier = findMarker(original, StyleKind.PrettierStyle) !== undefined;
+                const parent = new Cursor(cu, this.cursor);
+                const appended: J.RightPadded<any>[] = [];
+                for (const [i, padded] of parsed.statements.entries()) {
+                    // The parser files the first statement's comment under the compilation unit.
+                    let declaration = i === 0
+                        ? {...padded.element, prefix: {...parsed.prefix, whitespace: '\n\n'}} as J
+                        : padded.element as J;
+                    if (prettier) declaration = await autoFormat(declaration, p, undefined, parent);
+                    appended.push({...padded, element: declaration});
+                }
+                return {...cu, statements: [...cu.statements, ...appended]} as JS.CompilationUnit;
+            }
+
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (m?.kind !== J.Kind.MethodInvocation) return m;
+                if (this.isInstall(m)) {
+                    const args = m.arguments.elements.map(a => a.element).filter(a => a.kind !== J.Kind.Empty);
+                    // More than one argument is no `install` call this can read, and native options are the native recipes'.
+                    if (args.length > 1 || hasOnlyNativeOptions(args[0])) return m;
+                    if (isBrowserInstall(args[0])) {
+                        if (this.isTopLevelStatement()) this.browserInstalls.add(m.id);
+                        return m;
+                    }
+                    if (!m.select) this.members.add('install');
+                    return this.call(m, 'installSourceMapSupport');
+                }
+                const select = m.select?.element;
+                const declaration = VALUE_MEMBERS.get(m.name.simpleName);
+                if (!select || !declaration || declaration === 'installSourceMapSupport' || !this.isModuleObject(select)) return m;
+                return this.call(m, declaration);
+            }
+
+            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: ExecutionContext): Promise<J | undefined> {
+                const f = await super.visitFieldAccess(fieldAccess, p) as J.FieldAccess;
+                // Assigning a member changes the library for other modules, which a local function can't.
+                if (f?.kind !== J.Kind.FieldAccess || !this.isModuleObject(f.target) || isWriteTarget(this.cursor)) return f;
+                const member = f.name.element.simpleName;
+                const declaration = this.inTypePosition() ? TYPE_MEMBERS.get(member) : VALUE_MEMBERS.get(member);
+                if (!declaration) return f;
+                this.needed.add(declaration);
+                return identifier(f.prefix, placeholder(declaration));
+            }
+
+            override async visitIdentifier(ident: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                const id = await super.visitIdentifier(ident, p) as J.Identifier;
+                const declaration = this.renames.get(ident.id);
+                if (id?.kind !== J.Kind.Identifier || !declaration) return id;
+                this.needed.add(declaration);
+                return {...id, simpleName: placeholder(declaration)} as J.Identifier;
+            }
+
+            /** `m` calling `declaration` directly, its arguments as written. */
+            private call(m: J.MethodInvocation, declaration: ApiDeclaration): J.MethodInvocation {
+                this.needed.add(declaration);
+                return {...m, select: undefined, name: {...m.name, prefix: emptySpace, simpleName: placeholder(declaration)}};
+            }
+
+            /** The module itself, as a whole-module binding or a `require` of it. */
+            private isModuleObject(e: J | undefined): boolean {
+                if (e?.kind === J.Kind.MethodInvocation) return MODULES.has(requiredModule(e) ?? '');
+                return !!e && isIdentifier(e) && this.bindings.has(e.simpleName) &&
+                    [undefined, '*'].includes(this.bindings.get(e.simpleName)) && isModuleScoped(this.cursor, e.simpleName);
+            }
+
+            private inTypePosition(): boolean {
+                return !!this.cursor.firstEnclosing((t: any): t is J => t?.kind === JS.Kind.TypeInfo);
+            }
+
+            /** Whether the cursor's call is a statement of the compilation unit, which can be removed whole. */
+            private isTopLevelStatement(): boolean {
+                const parent = this.cursor.parentTree();
+                const statement = parent?.value?.kind === JS.Kind.ExpressionStatement ? parent.parentTree() : parent;
+                return statement?.value?.kind === JS.Kind.CompilationUnit;
+            }
+        };
+    }
+}
+
+/** The call a statement consists of. */
+function statementCall(statement: J): J | undefined {
+    return statement.kind === JS.Kind.ExpressionStatement ? (statement as JS.ExpressionStatement).expression : statement;
+}

package/src/migrate/source-map-support/replace-source-map-support-install.ts

@@ -16,7 +16,8 @@ export class ReplaceSourceMapSupportInstall extends Recipe {
     readonly displayName = "Replace `source-map-support` with `process.setSourceMapsEnabled()`";
     readonly description = "Replaces `require('source-map-support').install()`, `import 'source-map-support/register'` and " +
         "their variants with Node's native `process.setSourceMapsEnabled(true)` (Node.js 16.6+). Calls passing options " +
-        "Node has no equivalent for (`retrieveSourceMap`, `retrieveFile`, `environment: 'browser'`, ...) are left alone. " +
+        "Node has no equivalent for (`retrieveSourceMap`, `retrieveFile`, `environment: 'browser'`, ...) are left to " +
+        "`ReplaceSourceMapSupportApi`. " +
         "Native source maps only apply to modules loaded after they are enabled, where `source-map-support` maps every " +
         "stack frame, so by default a call is only replaced where no other module is loaded before it: no other runtime " +
         "import in the file, and no earlier `require`. Elsewhere, launch Node with `--enable-source-maps`, which " +