@openrewrite/rewrite 8.70.0-20251219-160440 → 8.70.0-20251219-215811

package/src/javascript/markers.ts

@@ -18,7 +18,17 @@ 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, autodetect} from "./autodetect";
 
 declare module "./tree" {
     namespace JS {
@@ -107,19 +117,159 @@ 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> {
+        const id = await q.receive(before.id);
+        const styles = (await q.receiveList(before.styles))!;
+        return autodetect(id, 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 draft = createDraft(before);
+            for (const field of fields) {
+                (draft as any)[field] = await q.receive((before as any)[field]);
+            }
+            return finishDraft(draft) as T;
+        },
+
+        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> {
+        const draft = createDraft(before);
+        draft.beforeParentheses = await q.receive(before.beforeParentheses);
+        draft.aroundOperators = await q.receive(before.aroundOperators);
+        draft.beforeLeftBrace = await q.receive(before.beforeLeftBrace);
+        draft.beforeKeywords = await q.receive(before.beforeKeywords);
+        draft.within = await q.receive(before.within);
+        draft.ternaryOperator = await q.receive(before.ternaryOperator);
+        draft.other = await q.receive(before.other);
+        return finishDraft(draft) as SpacesStyle;
+    },
+
+    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> {
+        const draft = createDraft(before);
+        draft.ifStatement = await q.receive(before.ifStatement);
+        draft.keepWhenReformatting = await q.receive(before.keepWhenReformatting);
+        return finishDraft(draft) as WrappingAndBracesStyle;
+    },
+
+    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

@@ -50,7 +50,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 +264,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 +345,7 @@ export function createNodeResolutionResultMarker(
                 peerDependencies: undefined,
                 optionalDependencies: undefined,
                 engines: normalizeEngines(pkgEntry?.engines),
-                license: pkgEntry?.license,
+                license: normalizeLicense(pkgEntry?.license),
             });
             resolvedDependencyCache.set(key, resolved);
 

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