@openrewrite/rewrite 8.91.2 → 8.91.4

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/javascript/type-mapping.ts

@@ -19,6 +19,20 @@ import {Type} from "../java";
 import FUNCTION_TYPE_NAME = Type.FUNCTION_TYPE_NAME;
 import OBJECT_TYPE_NAME = Type.OBJECT_TYPE_NAME;
 
+/**
+ * TypeScript orders union constituents by internal type id, which varies with what the checker resolved
+ * earlier in the run; ordering by signature keeps a union's signature the same across parses. Intersections
+ * keep the order they were written in and are left alone. Call once `bounds` is attached to its owner, so
+ * a constituent that reaches back into it reads the whole constituent list rather than an empty one.
+ */
+function sortBySignature(bounds: Type[]): void {
+    const keys = new Map<Type, string>(bounds.map(b => [b, Type.signature(b)]));
+    bounds.sort((a, b) => {
+        const ka = keys.get(a)!, kb = keys.get(b)!;
+        return ka < kb ? -1 : ka > kb ? 1 : 0;
+    });
+}
+
 export class JavaScriptTypeMapping {
     // Primary cache: Use type signatures (preferring type.id) as cache keys
     // TypeScript assigns stable IDs to all types, so we don't need secondary caches
@@ -1610,6 +1624,7 @@ export class JavaScriptTypeMapping {
 
         // Update the bounds in the union we created
         (union as any).bounds = bounds;
+        sortBySignature(bounds);
 
         return union;
     }

package/src/javascript/visitor.ts

@@ -551,6 +551,7 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
         const updates: any = {
             prefix: await this.visitSpace(propertyAssignment.prefix, p),
             markers: await this.visitMarkers(propertyAssignment.markers, p),
+            modifiers: await mapAsync(propertyAssignment.modifiers, m => this.visitDefined<J.Modifier>(m, p)),
             name: await this.visitRightPadded(propertyAssignment.name, p),
             initializer: propertyAssignment.initializer && await this.visitDefined<Expression>(propertyAssignment.initializer, p)
         };

package/src/parser.ts

@@ -13,8 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import {createTwoFilesPatch} from "diff";
 import {ExecutionContext} from "./execution";
 import {SourceFile} from "./tree";
+import {TreePrinters} from "./print";
 import fs, {readFileSync} from "node:fs";
 import {isAbsolute, relative} from "path";
 import {ParseError, ParseErrorKind} from "./parse-error";
@@ -79,6 +81,27 @@ export abstract class Parser {
         return isAbsolute(path) && this.relativeTo ? relative(this.relativeTo, path) : path;
     }
 
+    /**
+     * A parse result that does not print back to its input has silently lost source, so it is reported as
+     * a `ParseError` carrying the tree that lost it. Mirrors `org.openrewrite.Parser`, down to the message.
+     * A parser whose LST cannot hold some byte of its input passes the form it can hold as `source`.
+     */
+    protected async requirePrintEqualsInput(sourceFile: SourceFile, input: ParserInput,
+                                            source: string = parserInputRead(input)): Promise<SourceFile> {
+        if (!this.ctx.getBoolean(ExecutionContext.REQUIRE_PRINT_EQUALS_INPUT, true)) {
+            return sourceFile;
+        }
+        const printed = await TreePrinters.print(sourceFile);
+        if (printed === source) {
+            return sourceFile;
+        }
+        const path = this.relativePath(input);
+        const diff = createTwoFilesPatch(path, path, source, printed, "", "", {context: 3});
+        const error = this.error(input, new Error(`${sourceFile.sourcePath} is not print idempotent. \n${diff}`));
+        const withErroneous: ParseError = {...error, erroneous: sourceFile};
+        return withErroneous;
+    }
+
     protected error(input: ParserInput, e: Error): ParseError {
         return {
             kind: ParseErrorKind,
@@ -88,7 +111,7 @@ export abstract class Parser {
                 id: randomId(),
                 parserType: this.constructor.name,
                 exceptionType: e.name,
-                message: e.message + ':\n' + e.stack,
+                message: e.stack ?? e.message,
             } satisfies ParseExceptionResult as ParseExceptionResult),
             text: parserInputRead(input),
             sourcePath: this.relativePath(input),

package/src/print.ts

@@ -162,8 +162,11 @@ export class TreePrinters {
         return this._registry.get(sourceFileKind)!;
     }
 
-    static print(sourceFile: SourceFile): Promise<string> {
-        return this.printer(sourceFile).print(sourceFile);
+    static async print(sourceFile: SourceFile): Promise<string> {
+        const printed = await this.printer(sourceFile).print(sourceFile);
+        // The BOM is a property of the file's encoding rather than of its syntax, so it is held on the
+        // source file and put back here. Mirrors `org.openrewrite.Tree.print`.
+        return sourceFile.charsetBomMarked && printed.charAt(0) !== "\uFEFF" ? "\uFEFF" + printed : printed;
     }
 
     static async printTrimmed(sourceFile: SourceFile): Promise<string> {

package/src/rpc/request/parse-project.ts

@@ -55,7 +55,11 @@ export class ParseProject {
          * If not specified, paths are relative to projectPath.
          * Use this when parsing a subdirectory but wanting paths relative to the repository root.
          */
-        private readonly relativeTo?: string
+        private readonly relativeTo?: string,
+        /**
+         * Parser options, as on the `Parse` request.
+         */
+        private readonly options?: { [key: string]: string }
     ) {}
 
     static handle(
@@ -85,7 +89,7 @@ export class ParseProject {
                     const prettierLoader = await projectParser.createPrettierLoader();
 
                     const resultItems: ParseProjectResponseItem[] = [];
-                    const ctx = new ExecutionContext();
+                    const ctx = new ExecutionContext({...request.options});
 
                     // Parse package.json files (these get NodeResolutionResult markers)
                     if (discovered.packageJsonFiles.length > 0) {

package/src/rpc/request/parse.ts

@@ -23,7 +23,12 @@ import * as path from "path";
 
 export class Parse {
     constructor(private readonly inputs: ParserInput[],
-                private readonly relativeTo?: string) {
+                private readonly relativeTo?: string,
+                /**
+                 * Parser options from the peer. Keys this handler does not recognize are ignored, and a
+                 * peer that sends none gets the parser's own defaults.
+                 */
+                private readonly options?: { [key: string]: string }) {
     }
 
     /**
@@ -58,7 +63,7 @@ export class Parse {
                         : "javascript";
 
                     const parser = Parsers.createParser(parserType, {
-                        ctx: new ExecutionContext(),
+                        ctx: new ExecutionContext({...request.options}),
                         relativeTo: request.relativeTo
                     })!;