@openrewrite/rewrite 8.91.3 → 8.91.5

package/src/javascript/scope.ts

@@ -152,6 +152,69 @@ export function namesDeclaredWithin(node: unknown, cacheKey: object = node as ob
     return names;
 }
 
+/**
+ * The names `node` reads and nothing within it binds, so each one reaches a binding further out.
+ * A name its parent introduces rather than reads is not one, nor is a name an inner scope rebinds:
+ * that reference reads the rebinding.
+ */
+export function namesReferencedWithin(node: unknown, cacheKey: object = node as object): ReadonlySet<string> {
+    if (cacheKey === null || typeof cacheKey !== 'object') {
+        return noNames;
+    }
+    const cached = referenced.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const names = new Set<string>();
+    collectReferences(node, undefined, undefined, names);
+    referenced.set(cacheKey, names);
+    return names;
+}
+
+/** The scopes enclosing a node, innermost first, each paired with what {@link frameBindings} reads. */
+interface Frames {
+    node: unknown;
+    parent: unknown;
+    outer?: Frames;
+}
+
+/** Whether a scope between the name and where the walk began binds it. */
+function shadowed(scopes: Frames | undefined, name: string): boolean {
+    for (let scope = scopes; scope; scope = scope.outer) {
+        if (frameBindings(scope.node, scope.parent).has(name)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function collectReferences(node: unknown, parent: unknown, scopes: Frames | undefined, names: Set<string>): void {
+    if (Array.isArray(node)) {
+        node.forEach(child => collectReferences(child, parent, scopes, names));
+        return;
+    }
+    const kind = (node as { kind?: string } | undefined)?.kind;
+    if (kind === J.Kind.RightPadded || kind === J.Kind.LeftPadded) {
+        // A naming position reads against the tree parent, so padding forwards the one it was handed.
+        collectReferences((node as J.RightPadded<any>).element, parent, scopes, names);
+        return;
+    }
+    if (kind === J.Kind.Container) {
+        collectReferences((node as J.Container<any>).elements, parent, scopes, names);
+        return;
+    }
+    if (!isTree(node)) {
+        return;
+    }
+    const name = kind === J.Kind.Identifier ? (node as J.Identifier).simpleName : undefined;
+    if (name && reads(node as J.Identifier, parent) && !shadowed(scopes, name)) {
+        names.add(name);
+    }
+    const within = scopeKinds.has(kind!) ? {node, parent, outer: scopes} : scopes;
+    Object.entries(node as object).forEach(([key, value]) =>
+        key !== 'markers' && collectReferences(value, node, within, names));
+}
+
 /**
  * Every name a binding pattern introduces. `member` is the property a name takes its value from,
  * which only a name an object pattern binds directly has: anything deeper reads a property of a
@@ -213,8 +276,12 @@ function frameBindings(node: any, parent: any): ReadonlySet<string> {
     // A function expression is the only function whose own name its body reaches: a declaration's
     // name belongs to the enclosing block, a method's to an instance.
     if (node?.kind === J.Kind.MethodDeclaration && parent?.kind === JS.Kind.StatementExpression) {
-        const self = bindingNames((node as J.MethodDeclaration).name).map(bound => bound.name);
-        return new Set([...self, ...ownBindings(node)]);
+        let names = selfNamed.get(node);
+        if (!names) {
+            const self = bindingNames((node as J.MethodDeclaration).name).map(bound => bound.name);
+            selfNamed.set(node, names = new Set([...self, ...ownBindings(node)]));
+        }
+        return names;
     }
     return ownBindings(node);
 }
@@ -369,7 +436,9 @@ const blockScoped = new Set(['let', 'const', 'using']);
 const hoisted = new WeakMap<object, string[]>();
 const declared = new WeakMap<object, ReadonlySet<string>>();
 const used = new WeakMap<object, ReadonlySet<string>>();
+const referenced = new WeakMap<object, ReadonlySet<string>>();
 const frames = new WeakMap<object, ReadonlySet<string>>();
+const selfNamed = new WeakMap<object, ReadonlySet<string>>();
 
 /**
  * The names blocks under `scope` hoist out to it. A `var` or function declaration reaches the whole
@@ -496,19 +565,46 @@ export function isValueReference(cursor: Cursor, identifier: J.Identifier): bool
     while (c && isPadding(c.value)) {
         c = c.parent;
     }
-    const parent = c?.value as
-        { kind?: string; name?: unknown; key?: unknown; label?: unknown; select?: unknown } | undefined;
+    return references(identifier, c?.value);
+}
+
+/** The position half of {@link isValueReference}, against a parent already found. */
+function references(identifier: J.Identifier, parent: unknown): boolean {
+    const owner = parent as {
+        kind?: string; name?: unknown; key?: unknown; label?: unknown; select?: unknown;
+        propertyName?: unknown;
+    } | undefined;
 
     // A call names a member of whatever it selects from. With nothing selected there is no member,
     // and its `name` is a reference to the function being called.
-    if (parent?.kind === J.Kind.MethodInvocation && !parent.select) {
+    if (owner?.kind === J.Kind.MethodInvocation && !owner.select) {
         return true;
     }
 
+    // A binding element names the property it destructures and binds under `name`, so both slots
+    // name rather than reference.
+    if (owner?.kind === JS.Kind.BindingElement && holds(owner.propertyName, identifier)) {
+        return false;
+    }
+
     // A JSX attribute keeps its prop name on `key`; the three label-bearing nodes keep theirs on
     // `label`. Every other kind that names rather than references keeps it on `name`.
-    const named = parent?.kind === JS.Kind.JsxAttribute ? parent.key : (parent?.name ?? parent?.label);
-    return named !== identifier && (named as { element?: unknown } | undefined)?.element !== identifier;
+    return !holds(owner?.kind === JS.Kind.JsxAttribute ? owner.key : (owner?.name ?? owner?.label), identifier);
+}
+
+/** Whether a node slot, padded or not, is the identifier itself. */
+function holds(slot: unknown, identifier: J.Identifier): boolean {
+    return slot === identifier || (slot as { element?: unknown } | undefined)?.element === identifier;
+}
+
+/**
+ * As {@link references}, for a collector rather than a renamer: a shorthand property's name slot is
+ * also the value it reads, which a rename has to expand rather than follow.
+ */
+function reads(identifier: J.Identifier, parent: unknown): boolean {
+    const owner = parent as { kind?: string; initializer?: unknown } | undefined;
+    return (owner?.kind === JS.Kind.PropertyAssignment && owner.initializer === undefined) ||
+        references(identifier, parent);
 }
 
 function isPadding(value: unknown): boolean {

package/src/javascript/tsconfig.ts

@@ -0,0 +1,177 @@
+/*
+ * 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 ts from "typescript";
+import * as path from "path";
+
+/**
+ * What a project gets to decide: where a module specifier resolves to, and which ambient
+ * declarations are in scope. The shape of the types themselves stays with the parser — `target`
+ * and `lib` bound the global scope, `strict` adds a `null` to every nullable type — which pins
+ * the widest view it can rather than the one a project compiles against.
+ */
+const RESOLUTION_OPTIONS: string[] = [
+    "baseUrl",
+    "paths",
+    // Internal companion to `paths`: the directory its entries resolve against.
+    "pathsBasePath",
+    "rootDirs",
+    "types",
+    "typeRoots",
+    "moduleResolution",
+    "moduleSuffixes",
+    "customConditions",
+    "resolvePackageJsonExports",
+    "resolvePackageJsonImports",
+    "resolveJsonModule",
+];
+
+/**
+ * Config file names in precedence order. TypeScript reads jsconfig.json for JavaScript
+ * projects, which is where a JS-only codebase states its `paths`.
+ */
+const CONFIG_FILE_NAMES = ["tsconfig.json", "jsconfig.json"];
+
+export interface ResolvedTsConfig {
+    /**
+     * Absolute path of the config file the options came from. Undefined when no project
+     * config applied, in which case {@link options} are the parser's defaults.
+     */
+    readonly configFilePath?: string;
+    readonly options: ts.CompilerOptions;
+}
+
+/**
+ * Finds the config file governing each file and merges its resolution options over a set of
+ * parser defaults, so that type-aware recipes see the same modules `tsc` would.
+ */
+export class TsConfigResolver {
+    private readonly configByDir = new Map<string, string | undefined>();
+    private readonly optionsByConfig = new Map<string, ts.CompilerOptions | undefined>();
+    private readonly root?: string;
+
+    /**
+     * @param defaults Options to fall back on, and to merge a project config over.
+     * @param relativeTo Root of the project being parsed, bounding the search. Without one,
+     *   walking up from the process working directory picks up whatever config sits above it.
+     */
+    constructor(private readonly defaults: ts.CompilerOptions, relativeTo?: string) {
+        this.root = relativeTo ? path.resolve(relativeTo) : undefined;
+    }
+
+    forFile(filePath: string): ResolvedTsConfig {
+        const configFilePath = this.findConfig(path.dirname(path.resolve(filePath)));
+        const options = configFilePath === undefined ? undefined : this.optionsFor(configFilePath);
+        return options === undefined ? {options: this.defaults} : {configFilePath, options};
+    }
+
+    /** The nearest config file at or below the project root, searching upwards. */
+    private findConfig(from: string): string | undefined {
+        if (!this.root || !isAtOrUnder(from, this.root)) {
+            return undefined;
+        }
+
+        const searched: string[] = [];
+        const memoize = (found: string | undefined) => {
+            for (const dir of searched) {
+                this.configByDir.set(dir, found);
+            }
+            return found;
+        };
+
+        for (let dir = from; ; dir = path.dirname(dir)) {
+            if (this.configByDir.has(dir)) {
+                return memoize(this.configByDir.get(dir));
+            }
+            searched.push(dir);
+
+            for (const configFileName of CONFIG_FILE_NAMES) {
+                const candidate = path.join(dir, configFileName);
+                if (ts.sys.fileExists(candidate)) {
+                    return memoize(candidate);
+                }
+            }
+            if (dir === this.root || path.dirname(dir) === dir) {
+                return memoize(undefined);
+            }
+        }
+    }
+
+    private optionsFor(configFilePath: string): ts.CompilerOptions | undefined {
+        if (!this.optionsByConfig.has(configFilePath)) {
+            this.optionsByConfig.set(configFilePath, this.merge(configFilePath));
+        }
+        return this.optionsByConfig.get(configFilePath);
+    }
+
+    /** Undefined where the config cannot be read, leaving the caller on its defaults. */
+    private merge(configFilePath: string): ts.CompilerOptions | undefined {
+        let projectOptions: ts.CompilerOptions;
+        try {
+            const {config, error} = ts.readConfigFile(configFilePath, ts.sys.readFile);
+            if (error || !config) {
+                return undefined;
+            }
+            // `readDirectory` answers empty because only `options` is read here; left to `ts.sys` it
+            // walks the whole tree under the config to build a file list, once per config found.
+            const parseConfigHost: ts.ParseConfigHost = {...ts.sys, readDirectory: () => []};
+            projectOptions = ts.parseJsonConfigFileContent(
+                config, parseConfigHost, path.dirname(configFilePath), undefined, configFilePath).options;
+        } catch {
+            return undefined;
+        }
+
+        // A project's `baseUrl` stands alone, including where it states none: `baseUrl` takes
+        // precedence over `pathsBasePath`, so a default rooted at the repository would resolve a
+        // nested project's `paths` against the wrong directory.
+        const {baseUrl: _, ...defaults} = this.defaults;
+
+        const resolution: ts.CompilerOptions = {};
+        for (const option of RESOLUTION_OPTIONS) {
+            if (projectOptions[option] !== undefined) {
+                resolution[option] = projectOptions[option];
+            }
+        }
+        if (resolution.moduleResolution === undefined) {
+            const paired = pairedModuleResolution(projectOptions);
+            if (paired !== undefined) {
+                resolution.moduleResolution = paired;
+            }
+        }
+        return {...defaults, ...resolution};
+    }
+}
+
+/**
+ * The resolution TypeScript infers for a project that states only its `module`. Only the
+ * inference is adopted, since a module kind such as `node16` classifies files as CJS or ESM,
+ * and an ESM-only import from a CJS file is then the error TS1479, costing the file its LST.
+ * `Classic` is declined as well, searching no `node_modules`, so the default stands in.
+ */
+function pairedModuleResolution(projectOptions: ts.CompilerOptions): ts.ModuleResolutionKind | undefined {
+    const infer = (ts as Partial<{ getEmitModuleResolutionKind(options: ts.CompilerOptions): ts.ModuleResolutionKind }>)
+        .getEmitModuleResolutionKind;
+    if (projectOptions.module === undefined || !infer) {
+        return undefined;
+    }
+    const inferred = infer(projectOptions);
+    return inferred === ts.ModuleResolutionKind.Classic ? undefined : inferred;
+}
+
+function isAtOrUnder(dir: string, root: string): boolean {
+    const relative = path.relative(root, dir);
+    return relative === "" ||
+        (relative !== ".." && !relative.startsWith(".." + path.sep) && !path.isAbsolute(relative));
+}

package/src/rpc/index.ts

@@ -33,7 +33,7 @@ export * from "./queue";
 export * from "../reference";
 export {RewriteRpc} from "./rewrite-rpc";
 export {RpcRecipe, RpcVisitor} from "./recipe";
-export {prepareJavaRecipe} from "./java-recipe";
+export {DelegatingRecipe, prepareJavaRecipe} from "./java-recipe";
 export {registerVisitor} from "./request/visitor-registry";
 
 RpcCodecs.registerCodec(TreeKind.Checksum, {

package/src/rpc/java-recipe.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 the original author or authors.
+ * Copyright 2026 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.
@@ -15,23 +15,110 @@
  */
 import {RewriteRpc} from "./rewrite-rpc";
 import type {RpcRecipe} from "./recipe";
+import {Recipe, RecipeDescriptor, ScanningRecipe} from "../recipe";
+import {TreeVisitor} from "../visitor";
+import {ExecutionContext} from "../execution";
+import {SourceFile} from "../tree";
 
 /**
- * Prepare a Java recipe via the active {@link RewriteRpc} connection.
- *
- * Routes a `PrepareRecipe` request to whichever side hosts the Java
- * implementation:
- *  - in production, the Java host that spawned the TS server (`dist/rpc/server.js`);
- *  - in tests, the JVM spawned via `JavaRpcTestServer` (see
- *    `@openrewrite/rewrite/test/java-rpc`).
- *
- * The returned {@link RpcRecipe} extends `Recipe`, so it can be used directly
- * as a recipe — e.g. assigned to `RecipeSpec.recipe` — or composed inside a
- * larger TS recipe (as the editor of a `check(usesType(...), ...)`
- * precondition, or as a step in `recipeList()`).
- *
- * Top-level convenience functions for specific Java recipes (e.g.
- * `addDependency`, `changeType`) sit naturally on top of this primitive:
+ * A stand-in for a Java recipe, composable like any other recipe (a `recipeList()` entry, a
+ * `check(...)` gate, a `RecipeSpec.recipe`). The Java host resolves it by name: from `delegatesTo`
+ * when it prepares the enclosing recipe, or by class name when it gates a visitor, like a `RecipeRef`.
+ * Only when this process runs it itself (a test, a JS-hosted run) is it prepared over the active
+ * {@link RewriteRpc} connection, on first use.
+ */
+export class DelegatingRecipe extends ScanningRecipe<number> {
+    readonly name: string;
+    readonly displayName: string;
+    readonly description: string;
+    private delegate?: {rpc: RewriteRpc, recipe: Promise<RpcRecipe>};
+
+    constructor(readonly javaRecipeName: string,
+                readonly delegatesToOptions: Record<string, any>) {
+        super();
+        this.name = javaRecipeName;
+        this.displayName = javaRecipeName;
+        this.description = `Delegates to the Java recipe \`${javaRecipeName}\`.`;
+    }
+
+    // Local, with an empty recipe list: the host fills the subtree in, and recipeList() prepares the delegate.
+    async descriptor(): Promise<RecipeDescriptor> {
+        return {
+            name: this.name,
+            displayName: this.displayName,
+            instanceName: this.instanceName(),
+            description: this.description,
+            tags: this.tags,
+            estimatedEffortPerOccurrence: this.estimatedEffortPerOccurrence,
+            options: Object.entries(this.delegatesToOptions).map(([name, value]) => ({
+                name,
+                value,
+                displayName: name,
+                description: "",
+                required: false
+            })),
+            preconditions: [],
+            recipeList: [],
+            dataTables: this.dataTables,
+            maintainers: [],
+            contributors: [],
+            examples: []
+        };
+    }
+
+    async recipeList(): Promise<Recipe[]> {
+        return (await this.prepared()).recipeList();
+    }
+
+    initialValue(_ctx: ExecutionContext): number {
+        return 0;
+    }
+
+    async editorWithData(acc: number): Promise<TreeVisitor<any, ExecutionContext>> {
+        return (await this.prepared()).editorWithData(acc);
+    }
+
+    async scanner(acc: number): Promise<TreeVisitor<any, ExecutionContext>> {
+        return (await this.prepared()).scanner(acc);
+    }
+
+    async generate(acc: number, ctx: ExecutionContext): Promise<SourceFile[]> {
+        return (await this.prepared()).generate(acc, ctx);
+    }
+
+    async onComplete(ctx: ExecutionContext): Promise<void> {
+        if (this.delegate) {
+            await (await this.delegate.recipe).onComplete(ctx);
+        }
+    }
+
+    private prepared(): Promise<RpcRecipe> {
+        const rpc = RewriteRpc.get();
+        if (!rpc) {
+            throw new Error(
+                `Cannot run Java recipe "${this.javaRecipeName}": no active RewriteRpc connection.\n` +
+                "  • Tests: spawn one via JavaRpcTestServer.start() — see " +
+                "@openrewrite/rewrite/test/java-rpc.\n" +
+                "  • Production: the Java host provides one automatically when it " +
+                "loads the TS recipe artifact."
+            );
+        }
+        // Prepared once per connection; a failed prepare is dropped so the next use retries.
+        if (!this.delegate || this.delegate.rpc !== rpc) {
+            const recipe = rpc.prepareRecipe(this.javaRecipeName, this.delegatesToOptions);
+            this.delegate = {rpc, recipe};
+            recipe.catch(() => {
+                if (this.delegate?.recipe === recipe) {
+                    this.delegate = undefined;
+                }
+            });
+        }
+        return this.delegate.recipe;
+    }
+}
+
+/**
+ * Reference a Java recipe by name from a TS recipe:
  *
  * ```ts
  * export function addDependency(options: AddDependencyOptions): Promise<Recipe> {
@@ -39,26 +126,13 @@ import type {RpcRecipe} from "./recipe";
  * }
  * ```
  *
- * There is no in-process fallback by design: a Java recipe's editor is the
- * single source of truth — we don't reimplement editing recipes in TS. For
- * preconditions that need a graceful no-RPC fallback, use the {@link RecipeRef}
+ * There is no in-process fallback by design: a Java recipe's editor is the single source of
+ * truth. For preconditions that need a graceful no-RPC fallback, use the {@link RecipeRef}
  * pattern via `usesType` / `usesMethod`, which carries a `localVisitor`.
- *
- * @throws Error when no active {@link RewriteRpc} connection is registered.
  */
 export async function prepareJavaRecipe(
     id: string,
     options?: Record<string, any>,
-): Promise<RpcRecipe> {
-    const rpc = RewriteRpc.get();
-    if (!rpc) {
-        throw new Error(
-            `Cannot prepare Java recipe "${id}": no active RewriteRpc connection.\n` +
-            "  • Tests: spawn one via JavaRpcTestServer.start() — see " +
-            "@openrewrite/rewrite/test/java-rpc.\n" +
-            "  • Production: the Java host provides one automatically when it " +
-            "loads the TS recipe artifact."
-        );
-    }
-    return rpc.prepareRecipe(id, options);
+): Promise<DelegatingRecipe> {
+    return new DelegatingRecipe(id, options ?? {});
 }