@openrewrite/rewrite 8.70.0-20251219-180817 → 8.70.0-20251220-094504

package/src/javascript/markers.ts

@@ -17,8 +17,18 @@ import {Marker} from "../markers";
 import {J} from "../java";
 import {JS} from "./tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
-import {createDraft, finishDraft} from "immer";
-import {PrettierStyle, StyleKind} from "./style";
+import {
+    prettierStyle,
+    PrettierStyle,
+    SpacesStyle,
+    SpacesStyleDetailKind,
+    StyleKind,
+    TabsAndIndentsStyle,
+    WrappingAndBracesStyle,
+    WrappingAndBracesStyleDetailKind
+} from "./style";
+import {Autodetect} from "./autodetect";
+import {updateIfChanged} from "../util";
 
 declare module "./tree" {
     namespace JS {
@@ -86,10 +96,10 @@ function registerPrefixedMarkerCodec<M extends Marker & { prefix: J.Space }>(
 ) {
     RpcCodecs.registerCodec(kind, {
         async rpcReceive(before: M, q: RpcReceiveQueue): Promise<M> {
-            const draft = createDraft(before);
-            draft.id = await q.receive(before.id);
-            draft.prefix = await q.receive(before.prefix);
-            return finishDraft(draft) as M;
+            return updateIfChanged(before, {
+                id: await q.receive(before.id),
+                prefix: await q.receive(before.prefix)
+            } as Partial<M>);
         },
 
         async rpcSend(after: M, q: RpcSendQueue): Promise<void> {
@@ -107,19 +117,160 @@ registerPrefixedMarkerCodec<Spread>(JS.Markers.Spread);
 registerPrefixedMarkerCodec<FunctionDeclaration>(JS.Markers.FunctionDeclaration);
 
 // Register codec for PrettierStyle (a NamedStyles that contains Prettier configuration)
-// Only serialize the variable fields; constant fields are defined in the class
+// Only serialize the variable fields; constant fields are defined in the interface
 RpcCodecs.registerCodec(StyleKind.PrettierStyle, {
     async rpcReceive(before: PrettierStyle, q: RpcReceiveQueue): Promise<PrettierStyle> {
-        const draft = createDraft(before);
-        (draft as any).id = await q.receive(before.id);
-        (draft as any).config = await q.receive(before.config);
-        (draft as any).prettierVersion = await q.receive(before.prettierVersion);
-        return finishDraft(draft) as PrettierStyle;
+        const id = await q.receive(before.id);
+        const config = await q.receive(before.config);
+        const version = await q.receive(before.prettierVersion);
+        const ignored = await q.receive(before.ignored);
+        return prettierStyle(id, config, version, ignored);
     },
 
     async rpcSend(after: PrettierStyle, q: RpcSendQueue): Promise<void> {
         await q.getAndSend(after, a => a.id);
         await q.getAndSend(after, a => a.config);
         await q.getAndSend(after, a => a.prettierVersion);
+        await q.getAndSend(after, a => a.ignored);
+    }
+});
+
+// Register codec for Autodetect (auto-detected styles for JavaScript/TypeScript)
+// Only serialize the variable fields (id, styles); constant fields are defined in the interface
+RpcCodecs.registerCodec(StyleKind.Autodetect, {
+    async rpcReceive(before: Autodetect, q: RpcReceiveQueue): Promise<Autodetect> {
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            styles: (await q.receiveList(before.styles))!,
+        });
+    },
+
+    async rpcSend(after: Autodetect, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSendList(after, a => a.styles, s => s.kind);
+    }
+});
+
+// ============================================================================
+// Style RPC Codecs
+// ============================================================================
+
+// Helper to create a simple codec for objects where all fields are primitives
+function registerSimpleCodec<T extends { kind: string }>(
+    kind: T["kind"],
+    fields: (keyof T)[]
+) {
+    RpcCodecs.registerCodec(kind, {
+        async rpcReceive(before: T, q: RpcReceiveQueue): Promise<T> {
+            const updates: Partial<T> = {};
+            for (const field of fields) {
+                (updates as any)[field] = await q.receive((before as any)[field]);
+            }
+            return updateIfChanged(before, updates);
+        },
+
+        async rpcSend(after: T, q: RpcSendQueue): Promise<void> {
+            for (const field of fields) {
+                await q.getAndSend(after, a => (a as any)[field]);
+            }
+        }
+    });
+}
+
+// TabsAndIndentsStyle - simple style with primitive fields
+registerSimpleCodec<TabsAndIndentsStyle>(StyleKind.TabsAndIndentsStyle, [
+    'useTabCharacter', 'tabSize', 'indentSize', 'continuationIndent',
+    'keepIndentsOnEmptyLines', 'indentChainedMethods', 'indentAllChainedCallsInAGroup'
+]);
+
+// SpacesStyle and its nested types
+registerSimpleCodec<SpacesStyle.BeforeParentheses>(SpacesStyleDetailKind.SpacesStyleBeforeParentheses, [
+    'functionDeclarationParentheses', 'functionCallParentheses', 'ifParentheses',
+    'forParentheses', 'whileParentheses', 'switchParentheses', 'catchParentheses',
+    'inFunctionCallExpression', 'inAsyncArrowFunction'
+]);
+
+registerSimpleCodec<SpacesStyle.AroundOperators>(SpacesStyleDetailKind.SpacesStyleAroundOperators, [
+    'assignment', 'logical', 'equality', 'relational', 'bitwise', 'additive',
+    'multiplicative', 'shift', 'unary', 'arrowFunction',
+    'beforeUnaryNotAndNotNull', 'afterUnaryNotAndNotNull'
+]);
+
+registerSimpleCodec<SpacesStyle.BeforeLeftBrace>(SpacesStyleDetailKind.SpacesStyleBeforeLeftBrace, [
+    'functionLeftBrace', 'ifLeftBrace', 'elseLeftBrace', 'forLeftBrace',
+    'whileLeftBrace', 'doLeftBrace', 'switchLeftBrace', 'tryLeftBrace',
+    'catchLeftBrace', 'finallyLeftBrace', 'classInterfaceModuleLeftBrace'
+]);
+
+registerSimpleCodec<SpacesStyle.BeforeKeywords>(SpacesStyleDetailKind.SpacesStyleBeforeKeywords, [
+    'elseKeyword', 'whileKeyword', 'catchKeyword', 'finallyKeyword'
+]);
+
+registerSimpleCodec<SpacesStyle.Within>(SpacesStyleDetailKind.SpacesStyleWithin, [
+    'indexAccessBrackets', 'groupingParentheses', 'functionDeclarationParentheses',
+    'functionCallParentheses', 'ifParentheses', 'forParentheses', 'whileParentheses',
+    'switchParentheses', 'catchParentheses', 'objectLiteralBraces', 'es6ImportExportBraces',
+    'arrayBrackets', 'interpolationExpressions', 'objectLiteralTypeBraces',
+    'unionAndIntersectionTypes', 'typeAssertions'
+]);
+
+registerSimpleCodec<SpacesStyle.TernaryOperator>(SpacesStyleDetailKind.SpacesStyleTernaryOperator, [
+    'beforeQuestionMark', 'afterQuestionMark', 'beforeColon', 'afterColon'
+]);
+
+registerSimpleCodec<SpacesStyle.Other>(SpacesStyleDetailKind.SpacesStyleOther, [
+    'beforeComma', 'afterComma', 'beforeForSemicolon',
+    'beforePropertyNameValueSeparator', 'afterPropertyNameValueSeparator',
+    'afterVarArgInRestOrSpread', 'beforeAsteriskInGenerator', 'afterAsteriskInGenerator',
+    'beforeTypeReferenceColon', 'afterTypeReferenceColon'
+]);
+
+// SpacesStyle - has nested objects
+RpcCodecs.registerCodec(StyleKind.SpacesStyle, {
+    async rpcReceive(before: SpacesStyle, q: RpcReceiveQueue): Promise<SpacesStyle> {
+        return updateIfChanged(before, {
+            beforeParentheses: await q.receive(before.beforeParentheses),
+            aroundOperators: await q.receive(before.aroundOperators),
+            beforeLeftBrace: await q.receive(before.beforeLeftBrace),
+            beforeKeywords: await q.receive(before.beforeKeywords),
+            within: await q.receive(before.within),
+            ternaryOperator: await q.receive(before.ternaryOperator),
+            other: await q.receive(before.other),
+        });
+    },
+
+    async rpcSend(after: SpacesStyle, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.beforeParentheses);
+        await q.getAndSend(after, a => a.aroundOperators);
+        await q.getAndSend(after, a => a.beforeLeftBrace);
+        await q.getAndSend(after, a => a.beforeKeywords);
+        await q.getAndSend(after, a => a.within);
+        await q.getAndSend(after, a => a.ternaryOperator);
+        await q.getAndSend(after, a => a.other);
+    }
+});
+
+// WrappingAndBracesStyle and its nested types
+registerSimpleCodec<WrappingAndBracesStyle.IfStatement>(
+    WrappingAndBracesStyleDetailKind.WrappingAndBracesStyleIfStatement,
+    ['elseOnNewLine']
+);
+
+registerSimpleCodec<WrappingAndBracesStyle.KeepWhenReformatting>(
+    WrappingAndBracesStyleDetailKind.WrappingAndBracesStyleKeepWhenReformatting,
+    ['simpleBlocksInOneLine', 'simpleMethodsInOneLine']
+);
+
+RpcCodecs.registerCodec(StyleKind.WrappingAndBracesStyle, {
+    async rpcReceive(before: WrappingAndBracesStyle, q: RpcReceiveQueue): Promise<WrappingAndBracesStyle> {
+        return updateIfChanged(before, {
+            ifStatement: await q.receive(before.ifStatement),
+            keepWhenReformatting: await q.receive(before.keepWhenReformatting),
+        });
+    },
+
+    async rpcSend(after: WrappingAndBracesStyle, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.ifStatement);
+        await q.getAndSend(after, a => a.keepWhenReformatting);
     }
 });

package/src/javascript/node-resolution-result.ts

@@ -17,7 +17,8 @@ import {findMarker, Marker, Markers} from "../markers";
 import {randomId, UUID} from "../uuid";
 import {asRef} from "../reference";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
-import {castDraft, createDraft, finishDraft} from "immer";
+import {castDraft} from "immer";
+import {updateIfChanged} from "../util";
 import * as semver from "semver";
 import * as fsp from "fs/promises";
 import * as path from "path";
@@ -50,7 +51,7 @@ export interface PackageLockEntry {
     readonly version?: string;
     readonly resolved?: string;
     readonly integrity?: string;
-    readonly license?: string;
+    readonly license?: string | string[] | { type?: string; url?: string };  // Can be legacy formats
     readonly dependencies?: Record<string, string>;
     readonly devDependencies?: Record<string, string>;
     readonly peerDependencies?: Record<string, string>;
@@ -264,6 +265,27 @@ export function createNodeResolutionResultMarker(
         return engines;
     }
 
+    /**
+     * Normalizes the license field from package-lock.json.
+     * Older packages may have license in legacy formats:
+     * - Array: ["MIT", "Apache2"] -> "(MIT OR Apache2)"
+     * - Object: { type: "MIT", url: "..." } -> "MIT"
+     */
+    function normalizeLicense(license?: string | string[] | { type?: string; url?: string }): string | undefined {
+        if (!license) return undefined;
+        if (Array.isArray(license)) {
+            // Convert array format to SPDX OR expression
+            // e.g., ["MIT", "Apache2"] -> "(MIT OR Apache2)"
+            return license.length > 0 ? `(${license.join(' OR ')})` : undefined;
+        }
+        if (typeof license === 'object') {
+            // Extract type from object format
+            // e.g., { type: "MIT", url: "..." } -> "MIT"
+            return license.type || undefined;
+        }
+        return license;
+    }
+
     /**
      * Extracts package name and optionally version from a package-lock.json path.
      * e.g., "node_modules/@babel/core" -> { name: "@babel/core" }
@@ -324,7 +346,7 @@ export function createNodeResolutionResultMarker(
                 peerDependencies: undefined,
                 optionalDependencies: undefined,
                 engines: normalizeEngines(pkgEntry?.engines),
-                license: pkgEntry?.license,
+                license: normalizeLicense(pkgEntry?.license),
             });
             resolvedDependencyCache.set(key, resolved);
 
@@ -794,12 +816,11 @@ export namespace NodeResolutionResultQueries {
  */
 RpcCodecs.registerCodec(NpmrcKind, {
     async rpcReceive(before: Npmrc, q: RpcReceiveQueue): Promise<Npmrc> {
-        const draft = createDraft(before);
-        draft.kind = NpmrcKind;
-        draft.scope = await q.receive(before.scope);
-        draft.properties = await q.receive(before.properties);
-
-        return finishDraft(draft) as Npmrc;
+        return updateIfChanged(before, {
+            kind: NpmrcKind,
+            scope: await q.receive(before.scope),
+            properties: await q.receive(before.properties),
+        });
     },
 
     async rpcSend(after: Npmrc, q: RpcSendQueue): Promise<void> {
@@ -813,13 +834,12 @@ RpcCodecs.registerCodec(NpmrcKind, {
  */
 RpcCodecs.registerCodec(DependencyKind, {
     async rpcReceive(before: Dependency, q: RpcReceiveQueue): Promise<Dependency> {
-        const draft = createDraft(before);
-        draft.kind = DependencyKind;
-        draft.name = await q.receive(before.name);
-        draft.versionConstraint = await q.receive(before.versionConstraint);
-        draft.resolved = await q.receive(before.resolved);
-
-        return finishDraft(draft) as Dependency;
+        return updateIfChanged(before, {
+            kind: DependencyKind,
+            name: await q.receive(before.name),
+            versionConstraint: await q.receive(before.versionConstraint),
+            resolved: await q.receive(before.resolved),
+        });
     },
 
     async rpcSend(after: Dependency, q: RpcSendQueue): Promise<void> {
@@ -834,18 +854,17 @@ RpcCodecs.registerCodec(DependencyKind, {
  */
 RpcCodecs.registerCodec(ResolvedDependencyKind, {
     async rpcReceive(before: ResolvedDependency, q: RpcReceiveQueue): Promise<ResolvedDependency> {
-        const draft = createDraft(before);
-        draft.kind = ResolvedDependencyKind;
-        draft.name = await q.receive(before.name);
-        draft.version = await q.receive(before.version);
-        draft.dependencies = (await q.receiveList(before.dependencies)) || undefined;
-        draft.devDependencies = (await q.receiveList(before.devDependencies)) || undefined;
-        draft.peerDependencies = (await q.receiveList(before.peerDependencies)) || undefined;
-        draft.optionalDependencies = (await q.receiveList(before.optionalDependencies)) || undefined;
-        draft.engines = await q.receive(before.engines);
-        draft.license = await q.receive(before.license);
-
-        return finishDraft(draft) as ResolvedDependency;
+        return updateIfChanged(before, {
+            kind: ResolvedDependencyKind,
+            name: await q.receive(before.name),
+            version: await q.receive(before.version),
+            dependencies: (await q.receiveList(before.dependencies)) || undefined,
+            devDependencies: (await q.receiveList(before.devDependencies)) || undefined,
+            peerDependencies: (await q.receiveList(before.peerDependencies)) || undefined,
+            optionalDependencies: (await q.receiveList(before.optionalDependencies)) || undefined,
+            engines: await q.receive(before.engines),
+            license: await q.receive(before.license),
+        });
     },
 
     async rpcSend(after: ResolvedDependency, q: RpcSendQueue): Promise<void> {
@@ -867,29 +886,29 @@ RpcCodecs.registerCodec(ResolvedDependencyKind, {
 /**
  * Register RPC codec for NodeResolutionResult marker.
  * This handles serialization/deserialization for communication between JS and Java.
+ * Note: We avoid Immer here because the dependency graph can contain cycles
+ * (e.g., Dependency -> ResolvedDependency -> Dependency[]), and Immer's proxies
+ * don't handle cyclic structures correctly.
  */
 RpcCodecs.registerCodec(NodeResolutionResultKind, {
     async rpcReceive(before: NodeResolutionResult, q: RpcReceiveQueue): Promise<NodeResolutionResult> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.name = await q.receive(before.name);
-        draft.version = await q.receive(before.version);
-        draft.description = await q.receive(before.description);
-        draft.path = await q.receive(before.path);
-        draft.workspacePackagePaths = await q.receive(before.workspacePackagePaths);
-
-        draft.dependencies = (await q.receiveList(before.dependencies)) || [];
-        draft.devDependencies = (await q.receiveList(before.devDependencies)) || [];
-        draft.peerDependencies = (await q.receiveList(before.peerDependencies)) || [];
-        draft.optionalDependencies = (await q.receiveList(before.optionalDependencies)) || [];
-        draft.bundledDependencies = (await q.receiveList(before.bundledDependencies)) || [];
-        draft.resolvedDependencies = (await q.receiveList(before.resolvedDependencies)) || [];
-
-        draft.packageManager = await q.receive(before.packageManager);
-        draft.engines = await q.receive(before.engines);
-        draft.npmrcConfigs = (await q.receiveList(before.npmrcConfigs)) || undefined;
-
-        return finishDraft(draft) as NodeResolutionResult;
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            name: await q.receive(before.name),
+            version: await q.receive(before.version),
+            description: await q.receive(before.description),
+            path: await q.receive(before.path),
+            workspacePackagePaths: await q.receive(before.workspacePackagePaths),
+            dependencies: (await q.receiveList(before.dependencies)) || [],
+            devDependencies: (await q.receiveList(before.devDependencies)) || [],
+            peerDependencies: (await q.receiveList(before.peerDependencies)) || [],
+            optionalDependencies: (await q.receiveList(before.optionalDependencies)) || [],
+            bundledDependencies: (await q.receiveList(before.bundledDependencies)) || [],
+            resolvedDependencies: (await q.receiveList(before.resolvedDependencies)) || [],
+            packageManager: await q.receive(before.packageManager),
+            engines: await q.receive(before.engines),
+            npmrcConfigs: (await q.receiveList(before.npmrcConfigs)) || undefined,
+        });
     },
 
     async rpcSend(after: NodeResolutionResult, q: RpcSendQueue): Promise<void> {

package/src/javascript/package-json-parser.ts

@@ -107,12 +107,30 @@ export class PackageJsonParser extends Parser {
             entry.engines = pkgJson.engines;
         }
         if (pkgJson.license) {
-            entry.license = pkgJson.license;
+            // Normalize legacy license formats to string
+            entry.license = PackageJsonParser.normalizeLicense(pkgJson.license);
         }
 
         return entry;
     }
 
+    /**
+     * Normalizes the license field from package.json.
+     * Older packages may have license in legacy formats:
+     * - Array: ["MIT", "Apache2"] -> "(MIT OR Apache2)"
+     * - Object: { type: "MIT", url: "..." } -> "MIT"
+     */
+    private static normalizeLicense(license: any): string | undefined {
+        if (!license) return undefined;
+        if (Array.isArray(license)) {
+            return license.length > 0 ? `(${license.join(' OR ')})` : undefined;
+        }
+        if (typeof license === 'object' && license.type) {
+            return license.type;
+        }
+        return typeof license === 'string' ? license : undefined;
+    }
+
     /**
      * Accepts package.json files.
      */

package/src/javascript/parser.ts

@@ -48,12 +48,9 @@ import {
 } from "./parser-utils";
 import {JavaScriptTypeMapping} from "./type-mapping";
 import {produce} from "immer";
-import {PrettierConfigLoader} from "./format/prettier-config-loader";
-import Kind = JS.Kind;
 import ComputedPropertyName = JS.ComputedPropertyName;
 import Attribute = JSX.Attribute;
 import SpreadAttribute = JSX.SpreadAttribute;
-
 export interface JavaScriptParserOptions extends ParserOptions {
     styles?: NamedStyles[],
     sourceFileCache?: Map<string, ts.SourceFile>,
@@ -330,12 +327,6 @@ export class JavaScriptParser extends Parser {
         // Update the oldProgram reference
         this.oldProgram = program;
 
-        // Detect Prettier config for the project
-        const prettierLoader = this.relativeTo ? new PrettierConfigLoader(this.relativeTo) : undefined;
-        if (prettierLoader) {
-            await prettierLoader.detectPrettier();
-        }
-
         // Create a single JavaScriptTypeMapping instance to be shared across all files in this parse batch.
         // This ensures that TypeScript types with the same type.id map to the same Type instance,
         // preventing duplicate Type.Class, Type.Parameterized, etc. instances.
@@ -363,9 +354,6 @@ export class JavaScriptParser extends Parser {
             }
 
             try {
-                // Get Prettier config marker for this file (if Prettier is available)
-                const prettierConfigMarker = await prettierLoader?.getConfigMarker(filePath);
-
                 yield produce(
                     new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeMapping)
                         .visit(sourceFile) as SourceFile,
@@ -373,9 +361,6 @@ export class JavaScriptParser extends Parser {
                         if (this.styles) {
                             draft.markers.markers = draft.markers.markers.concat(this.styles);
                         }
-                        if (prettierConfigMarker) {
-                            draft.markers.markers = draft.markers.markers.concat([prettierConfigMarker]);
-                        }
                     });
             } catch (error) {
                 yield this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
@@ -1766,7 +1751,7 @@ export class JavaScriptParserVisitor {
                 markers: emptyMarkers,
                 typeParameter: this.rightPadded(
                     {
-                        kind: Kind.MappedTypeParameter,
+                        kind: JS.Kind.MappedTypeParameter,
                         id: randomId(),
                         prefix: this.prefix(node.typeParameter),
                         markers: emptyMarkers,

package/src/javascript/preconditions.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {RewriteRpc} from "../rpc";
+import {RewriteRpc} from "../rpc/rewrite-rpc";
 import {UsesMethod, UsesType} from "./search";
 import {ExecutionContext} from "../execution";
 import {TreeVisitor} from "../visitor";