@openrewrite/rewrite 8.70.0-20251222-101414 → 8.70.0-20251222-213047

package/src/visitor.ts

@@ -15,32 +15,21 @@
  */
 import {emptyMarkers, Marker, Markers} from "./markers";
 import {Cursor, isSourceFile, rootCursor, SourceFile, Tree} from "./tree";
-import {createDraft, Draft, finishDraft, nothing, Objectish} from "immer";
-import {mapAsync} from "./util";
+import {create, Draft} from "mutative";
+import {mapAsync, updateIfChanged} from "./util";
 
-/* Not exported beyond the internal immer module */
-export type ValidImmerRecipeReturnType<State> =
-    | State
-    | void
-    | undefined
-    | typeof nothing
+type Objectish = Record<string, any> | Array<any>;
+
+export type ValidRecipeReturnType<State> = State | void | undefined;
 
 export async function produceAsync<Base extends Objectish>(
     before: Promise<Base> | Base,
-    recipe: (draft: Draft<Base>) => ValidImmerRecipeReturnType<Draft<Base>> |
-        PromiseLike<ValidImmerRecipeReturnType<Draft<Base>>>
+    recipe: (draft: Draft<Base>) => ValidRecipeReturnType<Draft<Base>> |
+        PromiseLike<ValidRecipeReturnType<Draft<Base>>>
 ): Promise<Base | undefined> {
     const b: Base = await before;
-    const draft = createDraft(b);
-    const result = await recipe(draft);
-
-    // If recipe explicitly returned Immer's nothing, return undefined
-    if (result === nothing) {
-        return undefined;
-    }
-
-    // Otherwise, return the finished draft (void/undefined means use draft)
-    return finishDraft(draft) as Base;
+    // Mutative's create(base, recipe) supports async recipes and rawReturn(undefined)
+    return create(b, recipe as any) as Base | undefined;
 }
 
 const stopAfterPreVisit = Symbol.for("STOP_AFTER_PRE_VISIT")
@@ -136,9 +125,9 @@ export abstract class TreeVisitor<T extends Tree, P> {
         } else if ((markers.markers?.length || 0) === 0) {
             return markers;
         }
-        return (await produceAsync<Markers>(markers, async (draft) => {
-            draft.markers = await mapAsync(markers.markers, m => this.visitMarker(m, p))
-        }))!;
+        return updateIfChanged(markers, {
+            markers: await mapAsync(markers.markers, m => this.visitMarker(m, p))
+        });
     }
 
     protected async visitMarker<M extends Marker>(marker: M, p: P): Promise<M> {
@@ -149,15 +138,25 @@ export abstract class TreeVisitor<T extends Tree, P> {
         before: T,
         p: P,
         recipe?:
-            ((draft: Draft<T>) => ValidImmerRecipeReturnType<Draft<T>>) |
-            ((draft: Draft<T>) => Promise<ValidImmerRecipeReturnType<Draft<T>>>)
+            ((draft: Draft<T>) => ValidRecipeReturnType<Draft<T>>) |
+            ((draft: Draft<T>) => Promise<ValidRecipeReturnType<Draft<T>>>)
     ): Promise<T | undefined> {
-        return produceAsync(before, async draft => {
-            draft.markers = await this.visitMarkers(before.markers, p);
-            if (recipe) {
-                await recipe(draft);
+        // Visit markers separately to avoid Mutative drafting cyclic marker structures
+        const newMarkers = await this.visitMarkers(before.markers, p);
+
+        if (recipe) {
+            // Remove markers before Mutative drafting to avoid cycles, then restore after
+            const withoutMarkers = { ...before, markers: emptyMarkers };
+            const result = await produceAsync(withoutMarkers, recipe);
+            if (result === undefined) {
+                return undefined;
             }
-        });
+            // Restore markers (use newMarkers since we visited them)
+            return { ...result, markers: newMarkers } as T;
+        }
+
+        // No recipe - just update markers if changed
+        return updateIfChanged(before, { markers: newMarkers } as Partial<T>);
     }
 }
 

package/src/yaml/rpc.ts

@@ -16,8 +16,7 @@
 import {YamlVisitor} from "./visitor";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {Yaml} from "./tree";
-import {produceAsync} from "../visitor";
-import {createDraft, finishDraft} from "immer";
+import {updateIfChanged} from "../util";
 
 class YamlSender extends YamlVisitor<RpcSendQueue> {
 
@@ -116,118 +115,118 @@ class YamlSender extends YamlVisitor<RpcSendQueue> {
 class YamlReceiver extends YamlVisitor<RpcReceiveQueue> {
 
     protected async preVisit(y: Yaml, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(y);
-        draft.id = await q.receive(y.id);
-        draft.prefix = await q.receive(y.prefix);
-        draft.markers = await q.receive(y.markers);
-        return finishDraft(draft);
+        return updateIfChanged(y, {
+            id: await q.receive(y.id),
+            prefix: await q.receive(y.prefix),
+            markers: await q.receive(y.markers),
+        });
     }
 
     protected async visitDocuments(documents: Yaml.Documents, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(documents);
-        draft.sourcePath = await q.receive(documents.sourcePath);
-        draft.charsetName = await q.receive(documents.charsetName);
-        draft.charsetBomMarked = await q.receive(documents.charsetBomMarked);
-        draft.checksum = await q.receive(documents.checksum);
-        draft.fileAttributes = await q.receive(documents.fileAttributes);
-        draft.documents = await q.receiveListDefined(documents.documents,
-            async doc => await this.visit(doc, q) as Yaml.Document);
-        draft.suffix = await q.receive(documents.suffix);
-        return finishDraft(draft);
+        return updateIfChanged(documents, {
+            sourcePath: await q.receive(documents.sourcePath),
+            charsetName: await q.receive(documents.charsetName),
+            charsetBomMarked: await q.receive(documents.charsetBomMarked),
+            checksum: await q.receive(documents.checksum),
+            fileAttributes: await q.receive(documents.fileAttributes),
+            documents: await q.receiveListDefined(documents.documents,
+                async doc => await this.visit(doc, q) as Yaml.Document),
+            suffix: await q.receive(documents.suffix),
+        });
     }
 
     protected async visitDocument(document: Yaml.Document, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(document);
-        draft.explicit = await q.receive(document.explicit);
-        draft.block = await q.receive(document.block,
-            async b => await this.visit(b, q) as Yaml.Block);
-        draft.end = await q.receive(document.end,
-            async e => await this.visit(e, q) as Yaml.DocumentEnd);
-        return finishDraft(draft);
+        return updateIfChanged(document, {
+            explicit: await q.receive(document.explicit),
+            block: await q.receive(document.block,
+                async b => await this.visit(b, q) as Yaml.Block),
+            end: await q.receive(document.end,
+                async e => await this.visit(e, q) as Yaml.DocumentEnd),
+        });
     }
 
     protected async visitDocumentEnd(end: Yaml.DocumentEnd, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(end);
-        draft.explicit = await q.receive(end.explicit);
-        return finishDraft(draft);
+        return updateIfChanged(end, {
+            explicit: await q.receive(end.explicit),
+        });
     }
 
     protected async visitMapping(mapping: Yaml.Mapping, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(mapping);
-        draft.openingBracePrefix = await q.receive(mapping.openingBracePrefix);
-        draft.entries = await q.receiveListDefined(mapping.entries,
-            async e => await this.visit(e, q) as Yaml.MappingEntry);
-        draft.closingBracePrefix = await q.receive(mapping.closingBracePrefix);
-        draft.anchor = await q.receive(mapping.anchor,
-            async a => a ? await this.visit(a, q) as Yaml.Anchor : undefined);
-        draft.tag = await q.receive(mapping.tag,
-            async t => t ? await this.visit(t, q) as Yaml.Tag : undefined);
-        return finishDraft(draft);
+        return updateIfChanged(mapping, {
+            openingBracePrefix: await q.receive(mapping.openingBracePrefix),
+            entries: await q.receiveListDefined(mapping.entries,
+                async e => await this.visit(e, q) as Yaml.MappingEntry),
+            closingBracePrefix: await q.receive(mapping.closingBracePrefix),
+            anchor: await q.receive(mapping.anchor,
+                async a => a ? await this.visit(a, q) as Yaml.Anchor : undefined),
+            tag: await q.receive(mapping.tag,
+                async t => t ? await this.visit(t, q) as Yaml.Tag : undefined),
+        });
     }
 
     protected async visitMappingEntry(entry: Yaml.MappingEntry, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(entry);
-        draft.key = await q.receive(entry.key,
-            async k => await this.visit(k, q) as Yaml.YamlKey);
-        draft.beforeMappingValueIndicator = await q.receive(entry.beforeMappingValueIndicator);
-        draft.value = await q.receive(entry.value,
-            async v => await this.visit(v, q) as Yaml.Block);
-        return finishDraft(draft);
+        return updateIfChanged(entry, {
+            key: await q.receive(entry.key,
+                async k => await this.visit(k, q) as Yaml.YamlKey),
+            beforeMappingValueIndicator: await q.receive(entry.beforeMappingValueIndicator),
+            value: await q.receive(entry.value,
+                async v => await this.visit(v, q) as Yaml.Block),
+        });
     }
 
     protected async visitScalar(scalar: Yaml.Scalar, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(scalar);
-        draft.style = await q.receive(scalar.style);
-        draft.anchor = await q.receive(scalar.anchor,
-            async a => a ? await this.visit(a, q) as Yaml.Anchor : undefined);
-        draft.tag = await q.receive(scalar.tag,
-            async t => t ? await this.visit(t, q) as Yaml.Tag : undefined);
-        draft.value = await q.receive(scalar.value);
-        return finishDraft(draft);
+        return updateIfChanged(scalar, {
+            style: await q.receive(scalar.style),
+            anchor: await q.receive(scalar.anchor,
+                async a => a ? await this.visit(a, q) as Yaml.Anchor : undefined),
+            tag: await q.receive(scalar.tag,
+                async t => t ? await this.visit(t, q) as Yaml.Tag : undefined),
+            value: await q.receive(scalar.value),
+        });
     }
 
     protected async visitSequence(sequence: Yaml.Sequence, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(sequence);
-        draft.openingBracketPrefix = await q.receive(sequence.openingBracketPrefix);
-        draft.entries = await q.receiveListDefined(sequence.entries,
-            async e => await this.visit(e, q) as Yaml.SequenceEntry);
-        draft.closingBracketPrefix = await q.receive(sequence.closingBracketPrefix);
-        draft.anchor = await q.receive(sequence.anchor,
-            async a => a ? await this.visit(a, q) as Yaml.Anchor : undefined);
-        draft.tag = await q.receive(sequence.tag,
-            async t => t ? await this.visit(t, q) as Yaml.Tag : undefined);
-        return finishDraft(draft);
+        return updateIfChanged(sequence, {
+            openingBracketPrefix: await q.receive(sequence.openingBracketPrefix),
+            entries: await q.receiveListDefined(sequence.entries,
+                async e => await this.visit(e, q) as Yaml.SequenceEntry),
+            closingBracketPrefix: await q.receive(sequence.closingBracketPrefix),
+            anchor: await q.receive(sequence.anchor,
+                async a => a ? await this.visit(a, q) as Yaml.Anchor : undefined),
+            tag: await q.receive(sequence.tag,
+                async t => t ? await this.visit(t, q) as Yaml.Tag : undefined),
+        });
     }
 
     protected async visitSequenceEntry(entry: Yaml.SequenceEntry, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(entry);
-        draft.block = await q.receive(entry.block,
-            async b => await this.visit(b, q) as Yaml.Block);
-        draft.dash = await q.receive(entry.dash);
-        draft.trailingCommaPrefix = await q.receive(entry.trailingCommaPrefix);
-        return finishDraft(draft);
+        return updateIfChanged(entry, {
+            block: await q.receive(entry.block,
+                async b => await this.visit(b, q) as Yaml.Block),
+            dash: await q.receive(entry.dash),
+            trailingCommaPrefix: await q.receive(entry.trailingCommaPrefix),
+        });
     }
 
     protected async visitAnchor(anchor: Yaml.Anchor, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(anchor);
-        draft.postfix = await q.receive(anchor.postfix);
-        draft.key = await q.receive(anchor.key);
-        return finishDraft(draft);
+        return updateIfChanged(anchor, {
+            postfix: await q.receive(anchor.postfix),
+            key: await q.receive(anchor.key),
+        });
     }
 
     protected async visitAlias(alias: Yaml.Alias, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(alias);
-        draft.anchor = await q.receive(alias.anchor,
-            async a => await this.visit(a, q) as Yaml.Anchor);
-        return finishDraft(draft);
+        return updateIfChanged(alias, {
+            anchor: await q.receive(alias.anchor,
+                async a => await this.visit(a, q) as Yaml.Anchor),
+        });
     }
 
     protected async visitTag(tag: Yaml.Tag, q: RpcReceiveQueue): Promise<Yaml | undefined> {
-        const draft = createDraft(tag);
-        draft.name = await q.receive(tag.name);
-        draft.suffix = await q.receive(tag.suffix);
-        draft.tagKind = await q.receive(tag.tagKind);
-        return finishDraft(draft);
+        return updateIfChanged(tag, {
+            name: await q.receive(tag.name),
+            suffix: await q.receive(tag.suffix),
+            tagKind: await q.receive(tag.tagKind),
+        });
     }
 }