@openrewrite/rewrite 8.63.0 → 8.63.2

package/dist/java/rpc.js

@@ -29,9 +29,270 @@ exports.registerJLanguageCodecs = registerJLanguageCodecs;
 const visitor_1 = require("./visitor");
 const rpc_1 = require("../rpc");
 const tree_1 = require("./tree");
-const visitor_2 = require("../visitor");
-const immer_1 = require("immer");
 const tree_2 = require("../tree");
+const type_1 = require("./type");
+const type_visitor_1 = require("./type-visitor");
+const util_1 = require("../util");
+class TypeSender extends type_visitor_1.TypeVisitor {
+    visitPrimitive(primitive, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(primitive, p => p.keyword);
+            return primitive;
+        });
+    }
+    visitClass(cls, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(cls, c => c.flags);
+            yield q.getAndSend(cls, c => c.classKind);
+            yield q.getAndSend(cls, c => c.fullyQualifiedName);
+            yield q.getAndSendList(cls, c => (c.typeParameters || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), t => this.visit(t, q));
+            yield q.getAndSend(cls, c => (0, rpc_1.asRef)(c.supertype), st => this.visit(st, q));
+            yield q.getAndSend(cls, c => (0, rpc_1.asRef)(c.owningClass), oc => this.visit(oc, q));
+            yield q.getAndSendList(cls, c => (c.annotations || []).map(a => (0, rpc_1.asRef)(a)), t => type_1.Type.signature(t), a => this.visit(a, q));
+            yield q.getAndSendList(cls, c => (c.interfaces || []).map(i => (0, rpc_1.asRef)(i)), t => type_1.Type.signature(t), i => this.visit(i, q));
+            yield q.getAndSendList(cls, c => (c.members || []).map(m => (0, rpc_1.asRef)(m)), t => type_1.Type.signature(t), m => this.visit(m, q));
+            yield q.getAndSendList(cls, c => (c.methods || []).map(m => (0, rpc_1.asRef)(m)), t => type_1.Type.signature(t), m => this.visit(m, q));
+            return cls;
+        });
+    }
+    visitVariable(variable, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(variable, v => v.name);
+            yield q.getAndSend(variable, v => v.owner ? (0, rpc_1.asRef)(v.owner) : undefined, owner => this.visit(owner, q));
+            yield q.getAndSend(variable, v => (0, rpc_1.asRef)(v.type), t => this.visit(t, q));
+            yield q.getAndSendList(variable, v => (v.annotations || []).map(v2 => (0, rpc_1.asRef)(v2)), t => type_1.Type.signature(t), a => this.visit(a, q));
+            return variable;
+        });
+    }
+    visitAnnotation(annotation, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(annotation, a => (0, rpc_1.asRef)(a.type), t => this.visit(t, q));
+            // await q.getAndSendList(annotation, a => (a.values || []).map(v => asRef(v)), v => {
+            //     let value: any;
+            //     if (v.kind === Type.Kind.SingleElementValue) {
+            //         const single = v as Type.Annotation.SingleElementValue;
+            //         value = single.constantValue !== undefined ? single.constantValue : single.referenceValue;
+            //     } else {
+            //         const array = v as Type.Annotation.ArrayElementValue;
+            //         value = array.constantValues || array.referenceValues;
+            //     }
+            //     return `${Type.signature(v.element)}:${value == null ? "null" : value.toString()}`;
+            // }, async v => {
+            //     // Handle element values inline like the Java implementation
+            //     await q.getAndSend(v, e => asRef(e.element), elem => this.visit(elem, q));
+            //     if (v.kind === Type.Kind.SingleElementValue) {
+            //         const single = v as Type.Annotation.SingleElementValue;
+            //         await q.getAndSend(single, s => s.constantValue);
+            //         await q.getAndSend(single, s => asRef(s.referenceValue), ref => this.visit(ref, q));
+            //     } else if (v.kind === Type.Kind.ArrayElementValue) {
+            //         const array = v as Type.Annotation.ArrayElementValue;
+            //         await q.getAndSendList(array, a => a.constantValues || [], val => val == null ? "null" : val.toString());
+            //         await q.getAndSendList(array, a => (a.referenceValues || []).map(r => asRef(r)), t => Type.signature(t), r => this.visit(r, q));
+            //     }
+            // });
+            return annotation;
+        });
+    }
+    visitMethod(method, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(method, m => (0, rpc_1.asRef)(m.declaringType), dt => this.visit(dt, q));
+            yield q.getAndSend(method, m => m.name);
+            yield q.getAndSend(method, m => m.flags);
+            yield q.getAndSend(method, m => (0, rpc_1.asRef)(m.returnType), rt => this.visit(rt, q));
+            yield q.getAndSendList(method, m => m.parameterNames || [], v => v);
+            yield q.getAndSendList(method, m => (m.parameterTypes || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), pt => this.visit(pt, q));
+            yield q.getAndSendList(method, m => (m.thrownExceptions || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), et => this.visit(et, q));
+            yield q.getAndSendList(method, m => (m.annotations || []).map(a => (0, rpc_1.asRef)(a)), t => type_1.Type.signature(t), a => this.visit(a, q));
+            yield q.getAndSendList(method, m => m.defaultValue || undefined, v => v);
+            yield q.getAndSendList(method, m => m.declaredFormalTypeNames || [], v => v);
+            return method;
+        });
+    }
+    visitArray(array, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(array, a => (0, rpc_1.asRef)(a.elemType), et => this.visit(et, q));
+            yield q.getAndSendList(array, a => (a.annotations || []).map(ann => (0, rpc_1.asRef)(ann)), t => type_1.Type.signature(t), ann => this.visit(ann, q));
+            return array;
+        });
+    }
+    visitParameterized(parameterized, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(parameterized, p => (0, rpc_1.asRef)(p.type), t => this.visit(t, q));
+            yield q.getAndSendList(parameterized, p => (p.typeParameters || []).map(tp => (0, rpc_1.asRef)(tp)), t => type_1.Type.signature(t), tp => this.visit(tp, q));
+            return parameterized;
+        });
+    }
+    visitGenericTypeVariable(generic, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSend(generic, g => g.name);
+            // Convert TypeScript enum to Java enum string
+            yield q.getAndSend(generic, g => {
+                switch (g.variance) {
+                    case type_1.Type.GenericTypeVariable.Variance.Covariant:
+                        return 'COVARIANT';
+                    case type_1.Type.GenericTypeVariable.Variance.Contravariant:
+                        return 'CONTRAVARIANT';
+                    case type_1.Type.GenericTypeVariable.Variance.Invariant:
+                    default:
+                        return 'INVARIANT';
+                }
+            });
+            yield q.getAndSendList(generic, g => (g.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
+            return generic;
+        });
+    }
+    visitUnion(union, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSendList(union, u => (u.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
+            return union;
+        });
+    }
+    visitIntersection(intersection, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield q.getAndSendList(intersection, i => (i.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
+            return intersection;
+        });
+    }
+}
+class TypeReceiver extends type_visitor_1.TypeVisitor {
+    preVisit(_type, _q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Don't call default preVisit to avoid circular references
+            return _type;
+        });
+    }
+    postVisit(_type, _q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Don't call default postVisit to avoid circular references
+            return _type;
+        });
+    }
+    visitPrimitive(primitive, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyword = yield q.receive(primitive.keyword);
+            return type_1.Type.Primitive.fromKeyword(keyword);
+        });
+    }
+    visitClass(cls, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            cls.flags = yield q.receive(cls.flags);
+            cls.classKind = yield q.receive(cls.classKind);
+            cls.fullyQualifiedName = yield q.receive(cls.fullyQualifiedName);
+            cls.typeParameters = (yield q.receiveList(cls.typeParameters, tp => this.visit(tp, q))) || [];
+            cls.supertype = yield q.receive(cls.supertype, st => this.visit(st, q));
+            cls.owningClass = yield q.receive(cls.owningClass, oc => this.visit(oc, q));
+            cls.annotations = (yield q.receiveList(cls.annotations, a => this.visit(a, q))) || [];
+            cls.interfaces = (yield q.receiveList(cls.interfaces, i => this.visit(i, q))) || [];
+            cls.members = (yield q.receiveList(cls.members, m => this.visit(m, q))) || [];
+            cls.methods = (yield q.receiveList(cls.methods, m => this.visit(m, q))) || [];
+            return cls;
+        });
+    }
+    visitVariable(variable, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            variable.name = yield q.receive(variable.name);
+            variable.owner = yield q.receive(variable.owner, owner => this.visit(owner, q));
+            variable.type = yield q.receive(variable.type, t => this.visit(t, q));
+            variable.annotations = (yield q.receiveList(variable.annotations, a => this.visit(a, q))) || [];
+            return variable;
+        });
+    }
+    visitAnnotation(annotation, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            annotation.type = yield q.receive(annotation.type, t => this.visit(t, q));
+            // annotation.values = await q.receiveList(annotation.values, async v => {
+            //     // Handle element values inline like the Java implementation
+            //     if (v.kind === Type.Kind.SingleElementValue) {
+            //         const single = v as Type.Annotation.SingleElementValue;
+            //         const element = await q.receive(single.element, elem => this.visit(elem, q));
+            //         const constantValue = await q.receive(single.constantValue);
+            //         const referenceValue = await q.receive(single.referenceValue, ref => this.visit(ref, q));
+            //         return {
+            //             kind: Type.Kind.SingleElementValue,
+            //             element,
+            //             constantValue,
+            //             referenceValue
+            //         } as Type.Annotation.SingleElementValue;
+            //     } else if (v.kind === Type.Kind.ArrayElementValue) {
+            //         const array = v as Type.Annotation.ArrayElementValue;
+            //         const element = await q.receive(array.element, elem => this.visit(elem, q));
+            //         const constantValues = await q.receiveList(array.constantValues);
+            //         const referenceValues = await q.receiveList(array.referenceValues, r => this.visit(r, q));
+            //         return {
+            //             kind: Type.Kind.ArrayElementValue,
+            //             element,
+            //             constantValues,
+            //             referenceValues
+            //         } as Type.Annotation.ArrayElementValue;
+            //     }
+            //     return v;
+            // }) || [];
+            return annotation;
+        });
+    }
+    visitMethod(method, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            method.declaringType = yield q.receive(method.declaringType, dt => this.visit(dt, q));
+            method.name = yield q.receive(method.name);
+            method.flags = yield q.receive(method.flags);
+            method.returnType = yield q.receive(method.returnType, rt => this.visit(rt, q));
+            method.parameterNames = (yield q.receiveList(method.parameterNames)) || [];
+            method.parameterTypes = (yield q.receiveList(method.parameterTypes, pt => this.visit(pt, q))) || [];
+            method.thrownExceptions = (yield q.receiveList(method.thrownExceptions, et => this.visit(et, q))) || [];
+            method.annotations = (yield q.receiveList(method.annotations, a => this.visit(a, q))) || [];
+            method.defaultValue = yield q.receiveList(method.defaultValue);
+            method.declaredFormalTypeNames = (yield q.receiveList(method.declaredFormalTypeNames)) || [];
+            return method;
+        });
+    }
+    visitArray(array, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            array.elemType = yield q.receive(array.elemType, et => this.visit(et, q));
+            array.annotations = (yield q.receiveList(array.annotations, ann => this.visit(ann, q))) || [];
+            return array;
+        });
+    }
+    visitParameterized(parameterized, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            parameterized.type = yield q.receive(parameterized.type, t => this.visit(t, q));
+            parameterized.typeParameters = (yield q.receiveList(parameterized.typeParameters, tp => this.visit(tp, q))) || [];
+            return parameterized;
+        });
+    }
+    visitGenericTypeVariable(generic, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            generic.name = yield q.receive(generic.name);
+            const varianceStr = yield q.receive(generic.variance);
+            // Convert Java enum string to TypeScript enum
+            switch (varianceStr) {
+                case 'COVARIANT':
+                    generic.variance = type_1.Type.GenericTypeVariable.Variance.Covariant;
+                    break;
+                case 'CONTRAVARIANT':
+                    generic.variance = type_1.Type.GenericTypeVariable.Variance.Contravariant;
+                    break;
+                case 'INVARIANT':
+                default:
+                    generic.variance = type_1.Type.GenericTypeVariable.Variance.Invariant;
+                    break;
+            }
+            generic.bounds = (yield q.receiveList(generic.bounds, b => this.visit(b, q))) || [];
+            return generic;
+        });
+    }
+    visitUnion(union, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            union.bounds = (yield q.receiveList(union.bounds, b => this.visit(b, q))) || [];
+            return union;
+        });
+    }
+    visitIntersection(intersection, q) {
+        return __awaiter(this, void 0, void 0, function* () {
+            intersection.bounds = (yield q.receiveList(intersection.bounds, b => this.visit(b, q))) || [];
+            return intersection;
+        });
+    }
+}
 class JavaSender extends visitor_1.JavaVisitor {
     preVisit(j, q) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -663,22 +924,25 @@ class JavaSender extends visitor_1.JavaVisitor {
     }
     visitType(javaType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const codec = rpc_1.RpcCodecs.forInstance(javaType);
-            yield (codec === null || codec === void 0 ? void 0 : codec.rpcSend(javaType, q));
-            return javaType;
+            if (!javaType) {
+                return undefined;
+            }
+            return yield JavaSender.typeVisitor.visit(javaType, q);
         });
     }
 }
 exports.JavaSender = JavaSender;
+JavaSender.typeVisitor = new TypeSender();
 class JavaReceiver extends visitor_1.JavaVisitor {
     preVisit(j, q) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const draft = (0, immer_1.createDraft)(j);
-                draft.id = yield q.receive(j.id);
-                draft.prefix = yield q.receive(j.prefix, space => this.visitSpace(space, q));
-                draft.markers = yield q.receive(j.markers);
-                return (0, immer_1.finishDraft)(draft);
+                const updates = {
+                    id: yield q.receive(j.id),
+                    prefix: yield q.receive(j.prefix, space => this.visitSpace(space, q)),
+                    markers: yield q.receive(j.markers)
+                };
+                return (0, util_1.updateIfChanged)(j, updates);
             }
             catch (e) {
                 throw e;
@@ -687,129 +951,144 @@ class JavaReceiver extends visitor_1.JavaVisitor {
     }
     visitAnnotatedType(annotatedType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(annotatedType);
-            draft.annotations = yield q.receiveListDefined(annotatedType.annotations, annot => this.visit(annot, q));
-            draft.typeExpression = yield q.receive(annotatedType.typeExpression, type => this.visit(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(annotatedType.annotations, annot => this.visit(annot, q)),
+                typeExpression: yield q.receive(annotatedType.typeExpression, type => this.visit(type, q))
+            };
+            return (0, util_1.updateIfChanged)(annotatedType, updates);
         });
     }
     visitAnnotation(annotation, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(annotation);
-            draft.annotationType = yield q.receive(annotation.annotationType, type => this.visit(type, q));
-            draft.arguments = yield q.receive(annotation.arguments, args => this.visitContainer(args, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotationType: yield q.receive(annotation.annotationType, type => this.visit(type, q)),
+                arguments: yield q.receive(annotation.arguments, args => this.visitContainer(args, q))
+            };
+            return (0, util_1.updateIfChanged)(annotation, updates);
         });
     }
     visitArrayAccess(arrayAccess, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(arrayAccess);
-            draft.indexed = yield q.receive(arrayAccess.indexed, indexed => this.visit(indexed, q));
-            draft.dimension = yield q.receive(arrayAccess.dimension, dim => this.visit(dim, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                indexed: yield q.receive(arrayAccess.indexed, indexed => this.visit(indexed, q)),
+                dimension: yield q.receive(arrayAccess.dimension, dim => this.visit(dim, q))
+            };
+            return (0, util_1.updateIfChanged)(arrayAccess, updates);
         });
     }
     visitArrayDimension(dimension, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(dimension);
-            draft.index = yield q.receive(dimension.index, idx => this.visitRightPadded(idx, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                index: yield q.receive(dimension.index, idx => this.visitRightPadded(idx, q))
+            };
+            return (0, util_1.updateIfChanged)(dimension, updates);
         });
     }
     visitArrayType(arrayType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(arrayType);
-            draft.elementType = yield q.receive(arrayType.elementType, type => this.visit(type, q));
-            draft.annotations = yield q.receiveListDefined(arrayType.annotations || [], annot => this.visit(annot, q));
-            draft.dimension = yield q.receive(arrayType.dimension, d => this.visitLeftPadded(d, q));
-            draft.type = yield q.receive(arrayType.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                elementType: yield q.receive(arrayType.elementType, type => this.visit(type, q)),
+                annotations: yield q.receiveListDefined(arrayType.annotations || [], annot => this.visit(annot, q)),
+                dimension: yield q.receive(arrayType.dimension, d => this.visitLeftPadded(d, q)),
+                type: yield q.receive(arrayType.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(arrayType, updates);
         });
     }
     visitAssert(assert, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(assert);
-            draft.condition = yield q.receive(assert.condition, cond => this.visit(cond, q));
-            draft.detail = yield q.receive(assert.detail, detail => this.visitOptionalLeftPadded(detail, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                condition: yield q.receive(assert.condition, cond => this.visit(cond, q)),
+                detail: yield q.receive(assert.detail, detail => this.visitOptionalLeftPadded(detail, q))
+            };
+            return (0, util_1.updateIfChanged)(assert, updates);
         });
     }
     visitAssignment(assignment, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(assignment);
-            draft.variable = yield q.receive(assignment.variable, variable => this.visit(variable, q));
-            draft.assignment = yield q.receive(assignment.assignment, assign => this.visitLeftPadded(assign, q));
-            draft.type = yield q.receive(assignment.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                variable: yield q.receive(assignment.variable, variable => this.visit(variable, q)),
+                assignment: yield q.receive(assignment.assignment, assign => this.visitLeftPadded(assign, q)),
+                type: yield q.receive(assignment.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(assignment, updates);
         });
     }
     visitAssignmentOperation(assignOp, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(assignOp);
-            draft.variable = yield q.receive(assignOp.variable, variable => this.visit(variable, q));
-            draft.operator = yield q.receive(assignOp.operator, op => this.visitLeftPadded(op, q));
-            draft.assignment = yield q.receive(assignOp.assignment, assign => this.visit(assign, q));
-            draft.type = yield q.receive(assignOp.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                variable: yield q.receive(assignOp.variable, variable => this.visit(variable, q)),
+                operator: yield q.receive(assignOp.operator, op => this.visitLeftPadded(op, q)),
+                assignment: yield q.receive(assignOp.assignment, assign => this.visit(assign, q)),
+                type: yield q.receive(assignOp.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(assignOp, updates);
         });
     }
     visitBinary(binary, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(binary);
-            draft.left = yield q.receive(binary.left, left => this.visit(left, q));
-            draft.operator = yield q.receive(binary.operator, op => this.visitLeftPadded(op, q));
-            draft.right = yield q.receive(binary.right, right => this.visit(right, q));
-            draft.type = yield q.receive(binary.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                left: yield q.receive(binary.left, left => this.visit(left, q)),
+                operator: yield q.receive(binary.operator, op => this.visitLeftPadded(op, q)),
+                right: yield q.receive(binary.right, right => this.visit(right, q)),
+                type: yield q.receive(binary.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(binary, updates);
         });
     }
     visitBreak(breakStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(breakStmt);
-            draft.label = yield q.receive(breakStmt.label, label => this.visit(label, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                label: yield q.receive(breakStmt.label, label => this.visit(label, q))
+            };
+            return (0, util_1.updateIfChanged)(breakStmt, updates);
         });
     }
     visitCase(caseStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(caseStmt);
-            draft.type = yield q.receive(caseStmt.type);
-            draft.caseLabels = yield q.receive(caseStmt.caseLabels, labels => this.visitContainer(labels, q));
-            draft.statements = yield q.receive(caseStmt.statements, stmts => this.visitContainer(stmts, q));
-            draft.body = yield q.receive(caseStmt.body, body => this.visitRightPadded(body, q));
-            draft.guard = yield q.receive(caseStmt.guard, guard => this.visit(guard, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                type: yield q.receive(caseStmt.type),
+                caseLabels: yield q.receive(caseStmt.caseLabels, labels => this.visitContainer(labels, q)),
+                statements: yield q.receive(caseStmt.statements, stmts => this.visitContainer(stmts, q)),
+                body: yield q.receive(caseStmt.body, body => this.visitRightPadded(body, q)),
+                guard: yield q.receive(caseStmt.guard, guard => this.visit(guard, q))
+            };
+            return (0, util_1.updateIfChanged)(caseStmt, updates);
         });
     }
     visitContinue(continueStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(continueStmt);
-            draft.label = yield q.receive(continueStmt.label, label => this.visit(label, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                label: yield q.receive(continueStmt.label, label => this.visit(label, q))
+            };
+            return (0, util_1.updateIfChanged)(continueStmt, updates);
         });
     }
     visitControlParentheses(controlParens, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(controlParens);
-            draft.tree = (yield q.receive(controlParens.tree, tree => this.visitRightPadded(tree, q)));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                tree: yield q.receive(controlParens.tree, tree => this.visitRightPadded(tree, q))
+            };
+            return (0, util_1.updateIfChanged)(controlParens, updates);
         });
     }
     visitDeconstructionPattern(pattern, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(pattern);
-            draft.deconstructor = yield q.receive(pattern.deconstructor, deconstructor => this.visit(deconstructor, q));
-            draft.nested = yield q.receive(pattern.nested, nested => this.visitContainer(nested, q));
-            draft.type = yield q.receive(pattern.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                deconstructor: yield q.receive(pattern.deconstructor, deconstructor => this.visit(deconstructor, q)),
+                nested: yield q.receive(pattern.nested, nested => this.visitContainer(nested, q)),
+                type: yield q.receive(pattern.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(pattern, updates);
         });
     }
     visitDoWhileLoop(doWhile, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(doWhile);
-            draft.body = yield q.receive(doWhile.body, body => this.visitOptionalRightPadded(body, q));
-            draft.whileCondition = yield q.receive(doWhile.whileCondition, cond => this.visitLeftPadded(cond, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                body: yield q.receive(doWhile.body, body => this.visitOptionalRightPadded(body, q)),
+                whileCondition: yield q.receive(doWhile.whileCondition, cond => this.visitLeftPadded(cond, q))
+            };
+            return (0, util_1.updateIfChanged)(doWhile, updates);
         });
     }
     visitEmpty(empty) {
@@ -820,520 +1099,577 @@ class JavaReceiver extends visitor_1.JavaVisitor {
     }
     visitEnumValueSet(enumValueSet, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(enumValueSet);
-            draft.enums = yield q.receiveListDefined(enumValueSet.enums, enumValue => this.visitRightPadded(enumValue, q));
-            draft.terminatedWithSemicolon = yield q.receive(enumValueSet.terminatedWithSemicolon);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                enums: yield q.receiveListDefined(enumValueSet.enums, enumValue => this.visitRightPadded(enumValue, q)),
+                terminatedWithSemicolon: yield q.receive(enumValueSet.terminatedWithSemicolon)
+            };
+            return (0, util_1.updateIfChanged)(enumValueSet, updates);
         });
     }
     visitEnumValue(enumValue, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(enumValue);
-            draft.annotations = yield q.receiveListDefined(enumValue.annotations, annot => this.visit(annot, q));
-            draft.name = yield q.receive(enumValue.name, name => this.visit(name, q));
-            draft.initializer = yield q.receive(enumValue.initializer, init => this.visit(init, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(enumValue.annotations, annot => this.visit(annot, q)),
+                name: yield q.receive(enumValue.name, name => this.visit(name, q)),
+                initializer: yield q.receive(enumValue.initializer, init => this.visit(init, q))
+            };
+            return (0, util_1.updateIfChanged)(enumValue, updates);
         });
     }
     visitErroneous(erroneous, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(erroneous);
-            draft.text = yield q.receive(erroneous.text);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                text: yield q.receive(erroneous.text)
+            };
+            return (0, util_1.updateIfChanged)(erroneous, updates);
         });
     }
     visitFieldAccess(fieldAccess, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(fieldAccess);
-            draft.target = yield q.receive(fieldAccess.target, target => this.visit(target, q));
-            draft.name = yield q.receive(fieldAccess.name, name => this.visitLeftPadded(name, q));
-            draft.type = yield q.receive(fieldAccess.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                target: yield q.receive(fieldAccess.target, target => this.visit(target, q)),
+                name: yield q.receive(fieldAccess.name, name => this.visitLeftPadded(name, q)),
+                type: yield q.receive(fieldAccess.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(fieldAccess, updates);
         });
     }
     visitForEachLoop(forEachLoop, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(forEachLoop);
-            draft.control = yield q.receive(forEachLoop.control, c => this.visit(c, q));
-            draft.body = yield q.receive(forEachLoop.body, body => this.visitRightPadded(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                control: yield q.receive(forEachLoop.control, c => this.visit(c, q)),
+                body: yield q.receive(forEachLoop.body, body => this.visitRightPadded(body, q))
+            };
+            return (0, util_1.updateIfChanged)(forEachLoop, updates);
         });
     }
     visitForEachLoopControl(control, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(control);
-            draft.variable = yield q.receive(control.variable, variable => this.visitRightPadded(variable, q));
-            draft.iterable = yield q.receive(control.iterable, expr => this.visitRightPadded(expr, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                variable: yield q.receive(control.variable, variable => this.visitRightPadded(variable, q)),
+                iterable: yield q.receive(control.iterable, expr => this.visitRightPadded(expr, q))
+            };
+            return (0, util_1.updateIfChanged)(control, updates);
         });
     }
     visitForLoop(forLoop, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(forLoop);
-            draft.control = yield q.receive(forLoop.control, c => this.visit(c, q));
-            draft.body = yield q.receive(forLoop.body, body => this.visitRightPadded(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                control: yield q.receive(forLoop.control, c => this.visit(c, q)),
+                body: yield q.receive(forLoop.body, body => this.visitRightPadded(body, q))
+            };
+            return (0, util_1.updateIfChanged)(forLoop, updates);
         });
     }
     visitForLoopControl(control, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(control);
-            draft.init = yield q.receiveListDefined(control.init, init => this.visitRightPadded(init, q));
-            draft.condition = yield q.receive(control.condition, cond => this.visitRightPadded(cond, q));
-            draft.update = yield q.receiveListDefined(control.update, update => this.visitRightPadded(update, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                init: yield q.receiveListDefined(control.init, init => this.visitRightPadded(init, q)),
+                condition: yield q.receive(control.condition, cond => this.visitRightPadded(cond, q)),
+                update: yield q.receiveListDefined(control.update, update => this.visitRightPadded(update, q))
+            };
+            return (0, util_1.updateIfChanged)(control, updates);
         });
     }
     visitIf(ifStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(ifStmt);
-            draft.ifCondition = yield q.receive(ifStmt.ifCondition, cond => this.visit(cond, q));
-            draft.thenPart = yield q.receive(ifStmt.thenPart, thenPart => this.visitRightPadded(thenPart, q));
-            draft.elsePart = yield q.receive(ifStmt.elsePart, elsePart => this.visit(elsePart, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                ifCondition: yield q.receive(ifStmt.ifCondition, cond => this.visit(cond, q)),
+                thenPart: yield q.receive(ifStmt.thenPart, thenPart => this.visitRightPadded(thenPart, q)),
+                elsePart: yield q.receive(ifStmt.elsePart, elsePart => this.visit(elsePart, q))
+            };
+            return (0, util_1.updateIfChanged)(ifStmt, updates);
         });
     }
     visitElse(ifElse, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(ifElse);
-            draft.body = yield q.receive(ifElse.body, body => this.visitRightPadded(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                body: yield q.receive(ifElse.body, body => this.visitRightPadded(body, q))
+            };
+            return (0, util_1.updateIfChanged)(ifElse, updates);
         });
     }
     visitImport(importStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(importStmt);
-            draft.static = yield q.receive(importStmt.static, s => this.visitLeftPadded(s, q));
-            draft.qualid = yield q.receive(importStmt.qualid, qualid => this.visit(qualid, q));
-            draft.alias = yield q.receive(importStmt.alias, alias => this.visitLeftPadded(alias, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                static: yield q.receive(importStmt.static, s => this.visitLeftPadded(s, q)),
+                qualid: yield q.receive(importStmt.qualid, qualid => this.visit(qualid, q)),
+                alias: yield q.receive(importStmt.alias, alias => this.visitLeftPadded(alias, q))
+            };
+            return (0, util_1.updateIfChanged)(importStmt, updates);
         });
     }
     visitInstanceOf(instanceOf, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(instanceOf);
-            draft.expression = yield q.receive(instanceOf.expression, expr => this.visitRightPadded(expr, q));
-            draft.class = yield q.receive(instanceOf.class, clazz => this.visit(clazz, q));
-            draft.pattern = yield q.receive(instanceOf.pattern, pattern => this.visit(pattern, q));
-            draft.type = yield q.receive(instanceOf.type, type => this.visitType(type, q));
-            draft.modifier = yield q.receive(instanceOf.modifier, mod => this.visit(mod, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                expression: yield q.receive(instanceOf.expression, expr => this.visitRightPadded(expr, q)),
+                class: yield q.receive(instanceOf.class, clazz => this.visit(clazz, q)),
+                pattern: yield q.receive(instanceOf.pattern, pattern => this.visit(pattern, q)),
+                modifier: yield q.receive(instanceOf.modifier, mod => this.visit(mod, q)),
+                type: yield q.receive(instanceOf.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(instanceOf, updates);
         });
     }
     visitIntersectionType(intersectionType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(intersectionType);
-            draft.bounds = yield q.receive(intersectionType.bounds, bounds => this.visitContainer(bounds, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                bounds: yield q.receive(intersectionType.bounds, bounds => this.visitContainer(bounds, q))
+            };
+            return (0, util_1.updateIfChanged)(intersectionType, updates);
         });
     }
     visitLabel(label, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(label);
-            draft.label = yield q.receive(label.label, lbl => this.visitRightPadded(lbl, q));
-            draft.statement = yield q.receive(label.statement, stmt => this.visit(stmt, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                label: yield q.receive(label.label, lbl => this.visitRightPadded(lbl, q)),
+                statement: yield q.receive(label.statement, stmt => this.visit(stmt, q))
+            };
+            return (0, util_1.updateIfChanged)(label, updates);
         });
     }
     visitLambda(lambda, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(lambda);
-            draft.parameters = yield q.receive(lambda.parameters, params => this.visit(params, q));
-            draft.arrow = yield q.receive(lambda.arrow, arrow => this.visitSpace(arrow, q));
-            draft.body = yield q.receive(lambda.body, body => this.visit(body, q));
-            draft.type = yield q.receive(lambda.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                parameters: yield q.receive(lambda.parameters, params => this.visit(params, q)),
+                arrow: yield q.receive(lambda.arrow, arrow => this.visitSpace(arrow, q)),
+                body: yield q.receive(lambda.body, body => this.visit(body, q)),
+                type: yield q.receive(lambda.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(lambda, updates);
         });
     }
     visitLambdaParameters(params, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(params);
-            draft.parenthesized = yield q.receive(params.parenthesized);
-            draft.parameters = yield q.receiveListDefined(params.parameters, param => this.visitRightPadded(param, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                parenthesized: yield q.receive(params.parenthesized),
+                parameters: yield q.receiveListDefined(params.parameters, param => this.visitRightPadded(param, q))
+            };
+            return (0, util_1.updateIfChanged)(params, updates);
         });
     }
     visitLiteral(literal, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(literal);
-            draft.value = yield q.receive(literal.value);
-            draft.valueSource = yield q.receive(literal.valueSource);
-            draft.unicodeEscapes = yield q.receiveList(literal.unicodeEscapes);
-            draft.type = yield q.receive(literal.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                value: yield q.receive(literal.value),
+                valueSource: yield q.receive(literal.valueSource),
+                unicodeEscapes: yield q.receiveList(literal.unicodeEscapes),
+                type: yield q.receive(literal.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(literal, updates);
         });
     }
     visitMemberReference(memberRef, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(memberRef);
-            draft.containing = yield q.receive(memberRef.containing, container => this.visitRightPadded(container, q));
-            draft.typeParameters = yield q.receive(memberRef.typeParameters, typeParams => this.visitContainer(typeParams, q));
-            draft.reference = yield q.receive(memberRef.reference, ref => this.visitLeftPadded(ref, q));
-            draft.type = yield q.receive(memberRef.type, type => this.visitType(type, q));
-            draft.methodType = yield q.receive(memberRef.methodType, type => this.visitType(type, q));
-            draft.variableType = yield q.receive(memberRef.variableType, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                containing: yield q.receive(memberRef.containing, container => this.visitRightPadded(container, q)),
+                typeParameters: yield q.receive(memberRef.typeParameters, typeParams => this.visitContainer(typeParams, q)),
+                reference: yield q.receive(memberRef.reference, ref => this.visitLeftPadded(ref, q)),
+                type: yield q.receive(memberRef.type, type => this.visitType(type, q)),
+                methodType: yield q.receive(memberRef.methodType, type => this.visitType(type, q)),
+                variableType: yield q.receive(memberRef.variableType, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(memberRef, updates);
         });
     }
     visitMethodInvocation(methodInvoc, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(methodInvoc);
-            draft.select = yield q.receive(methodInvoc.select, select => this.visitRightPadded(select, q));
-            draft.typeParameters = yield q.receive(methodInvoc.typeParameters, typeParams => this.visitContainer(typeParams, q));
-            draft.name = yield q.receive(methodInvoc.name, name => this.visit(name, q));
-            draft.arguments = yield q.receive(methodInvoc.arguments, args => this.visitContainer(args, q));
-            draft.methodType = yield q.receive(methodInvoc.methodType, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                select: yield q.receive(methodInvoc.select, select => this.visitRightPadded(select, q)),
+                typeParameters: yield q.receive(methodInvoc.typeParameters, typeParams => this.visitContainer(typeParams, q)),
+                name: yield q.receive(methodInvoc.name, name => this.visit(name, q)),
+                arguments: yield q.receive(methodInvoc.arguments, args => this.visitContainer(args, q)),
+                methodType: yield q.receive(methodInvoc.methodType, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(methodInvoc, updates);
         });
     }
     visitModifier(modifier, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(modifier);
-            draft.keyword = yield q.receive(modifier.keyword);
-            draft.type = yield q.receive(modifier.type);
-            draft.annotations = yield q.receiveListDefined(modifier.annotations, annot => this.visit(annot, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                keyword: yield q.receive(modifier.keyword),
+                type: yield q.receive(modifier.type),
+                annotations: yield q.receiveListDefined(modifier.annotations, annot => this.visit(annot, q))
+            };
+            return (0, util_1.updateIfChanged)(modifier, updates);
         });
     }
     visitMultiCatch(multiCatch, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(multiCatch);
-            draft.alternatives = yield q.receiveListDefined(multiCatch.alternatives, alt => this.visitRightPadded(alt, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                alternatives: yield q.receiveListDefined(multiCatch.alternatives, alt => this.visitRightPadded(alt, q))
+            };
+            return (0, util_1.updateIfChanged)(multiCatch, updates);
         });
     }
     visitNewArray(newArray, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(newArray);
-            draft.typeExpression = yield q.receive(newArray.typeExpression, type => this.visit(type, q));
-            draft.dimensions = yield q.receiveListDefined(newArray.dimensions, dim => this.visit(dim, q));
-            draft.initializer = yield q.receive(newArray.initializer, init => this.visitContainer(init, q));
-            draft.type = yield q.receive(newArray.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                typeExpression: yield q.receive(newArray.typeExpression, type => this.visit(type, q)),
+                dimensions: yield q.receiveListDefined(newArray.dimensions, dim => this.visit(dim, q)),
+                initializer: yield q.receive(newArray.initializer, init => this.visitContainer(init, q)),
+                type: yield q.receive(newArray.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(newArray, updates);
         });
     }
     visitNewClass(newClass, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(newClass);
-            draft.enclosing = yield q.receive(newClass.enclosing, encl => this.visitRightPadded(encl, q));
-            draft.new = yield q.receive(newClass.new, new_ => this.visitSpace(new_, q));
-            draft.class = yield q.receive(newClass.class, clazz => this.visit(clazz, q));
-            draft.arguments = yield q.receive(newClass.arguments, args => this.visitContainer(args, q));
-            draft.body = yield q.receive(newClass.body, body => this.visit(body, q));
-            draft.constructorType = yield q.receive(newClass.constructorType, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                enclosing: yield q.receive(newClass.enclosing, encl => this.visitRightPadded(encl, q)),
+                new: yield q.receive(newClass.new, new_ => this.visitSpace(new_, q)),
+                class: yield q.receive(newClass.class, clazz => this.visit(clazz, q)),
+                arguments: yield q.receive(newClass.arguments, args => this.visitContainer(args, q)),
+                body: yield q.receive(newClass.body, body => this.visit(body, q)),
+                constructorType: yield q.receive(newClass.constructorType, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(newClass, updates);
         });
     }
     visitNullableType(nullableType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(nullableType);
-            draft.annotations = yield q.receiveListDefined(nullableType.annotations, annot => this.visit(annot, q));
-            draft.typeTree = yield q.receive(nullableType.typeTree, type => this.visitRightPadded(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(nullableType.annotations, annot => this.visit(annot, q)),
+                typeTree: yield q.receive(nullableType.typeTree, type => this.visitRightPadded(type, q))
+            };
+            return (0, util_1.updateIfChanged)(nullableType, updates);
         });
     }
     visitParameterizedType(paramType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(paramType);
-            draft.class = yield q.receive(paramType.class, clazz => this.visit(clazz, q));
-            draft.typeParameters = yield q.receive(paramType.typeParameters, params => this.visitContainer(params, q));
-            draft.type = yield q.receive(paramType.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                class: yield q.receive(paramType.class, clazz => this.visit(clazz, q)),
+                typeParameters: yield q.receive(paramType.typeParameters, params => this.visitContainer(params, q)),
+                type: yield q.receive(paramType.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(paramType, updates);
         });
     }
     visitParentheses(parentheses, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(parentheses);
-            draft.tree = (yield q.receive(parentheses.tree, tree => this.visitRightPadded(tree, q)));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                tree: yield q.receive(parentheses.tree, tree => this.visitRightPadded(tree, q))
+            };
+            return (0, util_1.updateIfChanged)(parentheses, updates);
         });
     }
     visitParenthesizedTypeTree(parenthesizedType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(parenthesizedType);
-            draft.annotations = yield q.receiveListDefined(parenthesizedType.annotations, annot => this.visit(annot, q));
-            draft.parenthesizedType = yield q.receive(parenthesizedType.parenthesizedType, tree => this.visit(tree, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(parenthesizedType.annotations, annot => this.visit(annot, q)),
+                parenthesizedType: yield q.receive(parenthesizedType.parenthesizedType, tree => this.visit(tree, q))
+            };
+            return (0, util_1.updateIfChanged)(parenthesizedType, updates);
         });
     }
     visitPrimitive(primitive, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(primitive);
-            draft.type = yield q.receive(primitive.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                type: yield q.receive(primitive.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(primitive, updates);
         });
     }
     visitSwitch(switchStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(switchStmt);
-            draft.selector = yield q.receive(switchStmt.selector, selector => this.visit(selector, q));
-            draft.cases = yield q.receive(switchStmt.cases, cases => this.visit(cases, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                selector: yield q.receive(switchStmt.selector, selector => this.visit(selector, q)),
+                cases: yield q.receive(switchStmt.cases, cases => this.visit(cases, q))
+            };
+            return (0, util_1.updateIfChanged)(switchStmt, updates);
         });
     }
     visitSwitchExpression(switchExpr, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(switchExpr);
-            draft.selector = yield q.receive(switchExpr.selector, selector => this.visit(selector, q));
-            draft.cases = yield q.receive(switchExpr.cases, cases => this.visit(cases, q));
-            draft.type = yield q.receive(switchExpr.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                selector: yield q.receive(switchExpr.selector, selector => this.visit(selector, q)),
+                cases: yield q.receive(switchExpr.cases, cases => this.visit(cases, q)),
+                type: yield q.receive(switchExpr.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(switchExpr, updates);
         });
     }
     visitTernary(ternary, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(ternary);
-            draft.condition = yield q.receive(ternary.condition, cond => this.visit(cond, q));
-            draft.truePart = yield q.receive(ternary.truePart, truePart => this.visitLeftPadded(truePart, q));
-            draft.falsePart = yield q.receive(ternary.falsePart, falsePart => this.visitLeftPadded(falsePart, q));
-            draft.type = yield q.receive(ternary.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                condition: yield q.receive(ternary.condition, cond => this.visit(cond, q)),
+                truePart: yield q.receive(ternary.truePart, truePart => this.visitLeftPadded(truePart, q)),
+                falsePart: yield q.receive(ternary.falsePart, falsePart => this.visitLeftPadded(falsePart, q)),
+                type: yield q.receive(ternary.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(ternary, updates);
         });
     }
     visitThrow(throwStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(throwStmt);
-            draft.exception = yield q.receive(throwStmt.exception, exception => this.visit(exception, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                exception: yield q.receive(throwStmt.exception, exception => this.visit(exception, q))
+            };
+            return (0, util_1.updateIfChanged)(throwStmt, updates);
         });
     }
     visitTry(tryStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(tryStmt);
-            draft.resources = yield q.receive(tryStmt.resources, resources => this.visitContainer(resources, q));
-            draft.body = yield q.receive(tryStmt.body, body => this.visit(body, q));
-            draft.catches = yield q.receiveListDefined(tryStmt.catches, catchBlock => this.visit(catchBlock, q));
-            draft.finally = yield q.receive(tryStmt.finally, finallyBlock => this.visitOptionalLeftPadded(finallyBlock, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                resources: yield q.receive(tryStmt.resources, resources => this.visitContainer(resources, q)),
+                body: yield q.receive(tryStmt.body, body => this.visit(body, q)),
+                catches: yield q.receiveListDefined(tryStmt.catches, catchBlock => this.visit(catchBlock, q)),
+                finally: yield q.receive(tryStmt.finally, finallyBlock => this.visitOptionalLeftPadded(finallyBlock, q))
+            };
+            return (0, util_1.updateIfChanged)(tryStmt, updates);
         });
     }
     visitTryResource(resource, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(resource);
-            draft.variableDeclarations = yield q.receive(resource.variableDeclarations, variables => this.visit(variables, q));
-            draft.terminatedWithSemicolon = yield q.receive(resource.terminatedWithSemicolon);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                variableDeclarations: yield q.receive(resource.variableDeclarations, variables => this.visit(variables, q)),
+                terminatedWithSemicolon: yield q.receive(resource.terminatedWithSemicolon)
+            };
+            return (0, util_1.updateIfChanged)(resource, updates);
         });
     }
     visitTryCatch(tryCatch, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(tryCatch);
-            draft.parameter = yield q.receive(tryCatch.parameter, param => this.visit(param, q));
-            draft.body = yield q.receive(tryCatch.body, body => this.visit(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                parameter: yield q.receive(tryCatch.parameter, param => this.visit(param, q)),
+                body: yield q.receive(tryCatch.body, body => this.visit(body, q))
+            };
+            return (0, util_1.updateIfChanged)(tryCatch, updates);
         });
     }
     visitUnary(unary, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(unary);
-            draft.operator = yield q.receive(unary.operator, op => this.visitLeftPadded(op, q));
-            draft.expression = yield q.receive(unary.expression, expr => this.visit(expr, q));
-            draft.type = yield q.receive(unary.type, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                operator: yield q.receive(unary.operator, op => this.visitLeftPadded(op, q)),
+                expression: yield q.receive(unary.expression, expr => this.visit(expr, q)),
+                type: yield q.receive(unary.type, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(unary, updates);
         });
     }
     visitUnknown(unknown, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(unknown);
-            draft.source = yield q.receive(unknown.source, source => this.visit(source, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                source: yield q.receive(unknown.source, source => this.visit(source, q))
+            };
+            return (0, util_1.updateIfChanged)(unknown, updates);
         });
     }
     visitUnknownSource(unknownSource, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(unknownSource);
-            draft.text = yield q.receive(unknownSource.text);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                text: yield q.receive(unknownSource.text)
+            };
+            return (0, util_1.updateIfChanged)(unknownSource, updates);
         });
     }
     visitVariable(variable, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(variable);
-            draft.name = yield q.receive(variable.name, name => this.visit(name, q));
-            draft.dimensionsAfterName = yield q.receiveListDefined(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, q));
-            draft.initializer = yield q.receive(variable.initializer, init => this.visitOptionalLeftPadded(init, q));
-            draft.variableType = yield q.receive(variable.variableType, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                name: yield q.receive(variable.name, name => this.visit(name, q)),
+                dimensionsAfterName: yield q.receiveListDefined(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, q)),
+                initializer: yield q.receive(variable.initializer, init => this.visitOptionalLeftPadded(init, q)),
+                variableType: yield q.receive(variable.variableType, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(variable, updates);
         });
     }
     visitYield(yieldStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(yieldStmt);
-            draft.implicit = yield q.receive(yieldStmt.implicit);
-            draft.value = yield q.receive(yieldStmt.value, value => this.visit(value, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                implicit: yield q.receive(yieldStmt.implicit),
+                value: yield q.receive(yieldStmt.value, value => this.visit(value, q))
+            };
+            return (0, util_1.updateIfChanged)(yieldStmt, updates);
         });
     }
     visitTypeParameters(typeParams, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(typeParams);
-            draft.annotations = yield q.receiveListDefined(typeParams.annotations, annot => this.visit(annot, q));
-            draft.typeParameters = yield q.receiveListDefined(typeParams.typeParameters, param => this.visitRightPadded(param, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(typeParams.annotations, annot => this.visit(annot, q)),
+                typeParameters: yield q.receiveListDefined(typeParams.typeParameters, param => this.visitRightPadded(param, q))
+            };
+            return (0, util_1.updateIfChanged)(typeParams, updates);
         });
     }
     visitReturn(returnStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(returnStmt);
-            draft.expression = yield q.receive(returnStmt.expression, expr => this.visit(expr, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                expression: yield q.receive(returnStmt.expression, expr => this.visit(expr, q))
+            };
+            return (0, util_1.updateIfChanged)(returnStmt, updates);
         });
     }
     visitSynchronized(synchronizedStmt, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(synchronizedStmt);
-            draft.lock = yield q.receive(synchronizedStmt.lock, lock => this.visit(lock, q));
-            draft.body = yield q.receive(synchronizedStmt.body, body => this.visit(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                lock: yield q.receive(synchronizedStmt.lock, lock => this.visit(lock, q)),
+                body: yield q.receive(synchronizedStmt.body, body => this.visit(body, q))
+            };
+            return (0, util_1.updateIfChanged)(synchronizedStmt, updates);
         });
     }
     visitTypeCast(typeCast, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(typeCast);
-            draft.class = yield q.receive(typeCast.class, typeExpr => this.visit(typeExpr, q));
-            draft.expression = yield q.receive(typeCast.expression, expr => this.visit(expr, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                class: yield q.receive(typeCast.class, typeExpr => this.visit(typeExpr, q)),
+                expression: yield q.receive(typeCast.expression, expr => this.visit(expr, q))
+            };
+            return (0, util_1.updateIfChanged)(typeCast, updates);
         });
     }
     visitTypeParameter(typeParameter, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(typeParameter);
-            draft.annotations = yield q.receiveListDefined(typeParameter.annotations, annot => this.visit(annot, q));
-            draft.modifiers = yield q.receiveListDefined(typeParameter.modifiers, annot => this.visit(annot, q));
-            draft.name = yield q.receive(typeParameter.name, name => this.visit(name, q));
-            draft.bounds = yield q.receive(typeParameter.bounds, bounds => this.visitContainer(bounds, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(typeParameter.annotations, annot => this.visit(annot, q)),
+                modifiers: yield q.receiveListDefined(typeParameter.modifiers, annot => this.visit(annot, q)),
+                name: yield q.receive(typeParameter.name, name => this.visit(name, q)),
+                bounds: yield q.receive(typeParameter.bounds, bounds => this.visitContainer(bounds, q))
+            };
+            return (0, util_1.updateIfChanged)(typeParameter, updates);
         });
     }
     visitWhileLoop(whileLoop, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(whileLoop);
-            draft.condition = yield q.receive(whileLoop.condition, cond => this.visit(cond, q));
-            draft.body = yield q.receive(whileLoop.body, body => this.visitOptionalRightPadded(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                condition: yield q.receive(whileLoop.condition, cond => this.visit(cond, q)),
+                body: yield q.receive(whileLoop.body, body => this.visitOptionalRightPadded(body, q))
+            };
+            return (0, util_1.updateIfChanged)(whileLoop, updates);
         });
     }
     visitWildcard(wildcard, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(wildcard);
-            draft.bound = yield q.receive(wildcard.bound, bound => this.visitLeftPadded(bound, q));
-            draft.boundedType = yield q.receive(wildcard.boundedType, type => this.visit(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                bound: yield q.receive(wildcard.bound, bound => this.visitLeftPadded(bound, q)),
+                boundedType: yield q.receive(wildcard.boundedType, type => this.visit(type, q))
+            };
+            return (0, util_1.updateIfChanged)(wildcard, updates);
         });
     }
     visitCompilationUnit(cu, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(cu);
-            draft.sourcePath = yield q.receive(cu.sourcePath);
-            draft.charsetName = yield q.receive(cu.charsetName);
-            draft.charsetBomMarked = yield q.receive(cu.charsetBomMarked);
-            draft.checksum = yield q.receive(cu.checksum);
-            draft.fileAttributes = yield q.receive(cu.fileAttributes);
-            draft.packageDeclaration = yield q.receive(cu.packageDeclaration, pkg => this.visitRightPadded(pkg, q));
-            draft.imports = yield q.receiveListDefined(cu.imports, imp => this.visitRightPadded(imp, q));
-            draft.classes = yield q.receiveListDefined(cu.classes, cls => this.visit(cls, q));
-            draft.eof = yield q.receive(cu.eof, space => this.visitSpace(space, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                sourcePath: yield q.receive(cu.sourcePath),
+                charsetName: yield q.receive(cu.charsetName),
+                charsetBomMarked: yield q.receive(cu.charsetBomMarked),
+                checksum: yield q.receive(cu.checksum),
+                fileAttributes: yield q.receive(cu.fileAttributes),
+                packageDeclaration: yield q.receive(cu.packageDeclaration, pkg => this.visitRightPadded(pkg, q)),
+                imports: yield q.receiveListDefined(cu.imports, imp => this.visitRightPadded(imp, q)),
+                classes: yield q.receiveListDefined(cu.classes, cls => this.visit(cls, q)),
+                eof: yield q.receive(cu.eof, space => this.visitSpace(space, q))
+            };
+            return (0, util_1.updateIfChanged)(cu, updates);
         });
     }
     visitPackage(pkg, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(pkg);
-            draft.expression = yield q.receive(pkg.expression, expr => this.visit(expr, q));
-            draft.annotations = yield q.receiveListDefined(pkg.annotations, annot => this.visit(annot, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                expression: yield q.receive(pkg.expression, expr => this.visit(expr, q)),
+                annotations: yield q.receiveListDefined(pkg.annotations, annot => this.visit(annot, q))
+            };
+            return (0, util_1.updateIfChanged)(pkg, updates);
         });
     }
     visitClassDeclaration(cls, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(cls);
-            draft.leadingAnnotations = yield q.receiveListDefined(cls.leadingAnnotations, annot => this.visit(annot, q));
-            draft.modifiers = yield q.receiveListDefined(cls.modifiers, mod => this.visit(mod, q));
-            draft.classKind = yield q.receive(cls.classKind, kind => this.visit(kind, q));
-            draft.name = yield q.receive(cls.name, name => this.visit(name, q));
-            draft.typeParameters = yield q.receive(cls.typeParameters, params => this.visitContainer(params, q));
-            draft.primaryConstructor = yield q.receive(cls.primaryConstructor, cons => this.visitContainer(cons, q));
-            draft.extends = yield q.receive(cls.extends, ext => this.visitLeftPadded(ext, q));
-            draft.implements = yield q.receive(cls.implements, impl => this.visitContainer(impl, q));
-            draft.permitting = yield q.receive(cls.permitting, perm => this.visitContainer(perm, q));
-            draft.body = yield q.receive(cls.body, body => this.visit(body, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                leadingAnnotations: yield q.receiveListDefined(cls.leadingAnnotations, annot => this.visit(annot, q)),
+                modifiers: yield q.receiveListDefined(cls.modifiers, mod => this.visit(mod, q)),
+                classKind: yield q.receive(cls.classKind, kind => this.visit(kind, q)),
+                name: yield q.receive(cls.name, name => this.visit(name, q)),
+                typeParameters: yield q.receive(cls.typeParameters, params => this.visitContainer(params, q)),
+                primaryConstructor: yield q.receive(cls.primaryConstructor, cons => this.visitContainer(cons, q)),
+                extends: yield q.receive(cls.extends, ext => this.visitLeftPadded(ext, q)),
+                implements: yield q.receive(cls.implements, impl => this.visitContainer(impl, q)),
+                permitting: yield q.receive(cls.permitting, perm => this.visitContainer(perm, q)),
+                body: yield q.receive(cls.body, body => this.visit(body, q))
+            };
+            return (0, util_1.updateIfChanged)(cls, updates);
         });
     }
     visitClassDeclarationKind(kind, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(kind);
-            draft.annotations = yield q.receiveListDefined(kind.annotations, annot => this.visit(annot, q));
-            draft.type = yield q.receive(kind.type);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(kind.annotations, annot => this.visit(annot, q)),
+                type: yield q.receive(kind.type)
+            };
+            return (0, util_1.updateIfChanged)(kind, updates);
         });
     }
     visitBlock(block, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(block);
-            draft.static = yield q.receive(block.static, s => this.visitRightPadded(s, q));
-            draft.statements = yield q.receiveListDefined(block.statements, stmt => this.visitRightPadded(stmt, q));
-            draft.end = yield q.receive(block.end, space => this.visitSpace(space, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                static: yield q.receive(block.static, s => this.visitRightPadded(s, q)),
+                statements: yield q.receiveListDefined(block.statements, stmt => this.visitRightPadded(stmt, q)),
+                end: yield q.receive(block.end, space => this.visitSpace(space, q))
+            };
+            return (0, util_1.updateIfChanged)(block, updates);
         });
     }
     visitMethodDeclaration(method, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(method);
-            draft.leadingAnnotations = yield q.receiveListDefined(method.leadingAnnotations, annot => this.visit(annot, q));
-            draft.modifiers = yield q.receiveListDefined(method.modifiers, mod => this.visit(mod, q));
-            draft.typeParameters = yield q.receive(method.typeParameters, params => this.visit(params, q));
-            draft.returnTypeExpression = yield q.receive(method.returnTypeExpression, type => this.visit(type, q));
-            draft.nameAnnotations = (yield q.receiveList(method.nameAnnotations, name => this.visit(name, q)));
-            draft.name = yield q.receive(method.name, name => this.visit(name, q));
-            draft.parameters = yield q.receive(method.parameters, params => this.visitContainer(params, q));
-            draft.throws = yield q.receive(method.throws, throws => this.visitContainer(throws, q));
-            draft.body = yield q.receive(method.body, body => this.visit(body, q));
-            draft.defaultValue = yield q.receive(method.defaultValue, def => this.visitLeftPadded(def, q));
-            draft.methodType = yield q.receive(method.methodType, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                leadingAnnotations: yield q.receiveListDefined(method.leadingAnnotations, annot => this.visit(annot, q)),
+                modifiers: yield q.receiveListDefined(method.modifiers, mod => this.visit(mod, q)),
+                typeParameters: yield q.receive(method.typeParameters, params => this.visit(params, q)),
+                returnTypeExpression: yield q.receive(method.returnTypeExpression, type => this.visit(type, q)),
+                nameAnnotations: (yield q.receiveList(method.nameAnnotations, name => this.visit(name, q))),
+                name: yield q.receive(method.name, name => this.visit(name, q)),
+                parameters: yield q.receive(method.parameters, params => this.visitContainer(params, q)),
+                throws: yield q.receive(method.throws, throws => this.visitContainer(throws, q)),
+                body: yield q.receive(method.body, body => this.visit(body, q)),
+                defaultValue: yield q.receive(method.defaultValue, def => this.visitLeftPadded(def, q)),
+                methodType: yield q.receive(method.methodType, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(method, updates);
         });
     }
     visitVariableDeclarations(varDecls, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(varDecls);
-            draft.leadingAnnotations = yield q.receiveListDefined(varDecls.leadingAnnotations, annot => this.visit(annot, q));
-            draft.modifiers = yield q.receiveListDefined(varDecls.modifiers, mod => this.visit(mod, q));
-            draft.typeExpression = yield q.receive(varDecls.typeExpression, type => this.visit(type, q));
-            draft.varargs = yield q.receive(varDecls.varargs, space => this.visitSpace(space, q));
-            draft.variables = yield q.receiveListDefined(varDecls.variables, variable => this.visitRightPadded(variable, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                leadingAnnotations: yield q.receiveListDefined(varDecls.leadingAnnotations, annot => this.visit(annot, q)),
+                modifiers: yield q.receiveListDefined(varDecls.modifiers, mod => this.visit(mod, q)),
+                typeExpression: yield q.receive(varDecls.typeExpression, type => this.visit(type, q)),
+                varargs: yield q.receive(varDecls.varargs, space => this.visitSpace(space, q)),
+                variables: yield q.receiveListDefined(varDecls.variables, variable => this.visitRightPadded(variable, q))
+            };
+            return (0, util_1.updateIfChanged)(varDecls, updates);
         });
     }
     visitIdentifier(ident, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(ident);
-            draft.annotations = yield q.receiveListDefined(ident.annotations, annot => this.visit(annot, q));
-            draft.simpleName = yield q.receive(ident.simpleName);
-            draft.type = yield q.receive(ident.type, type => this.visitType(type, q));
-            draft.fieldType = yield q.receive(ident.fieldType, type => this.visitType(type, q));
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                annotations: yield q.receiveListDefined(ident.annotations, annot => this.visit(annot, q)),
+                simpleName: yield q.receive(ident.simpleName),
+                type: yield q.receive(ident.type, type => this.visitType(type, q)),
+                fieldType: yield q.receive(ident.fieldType, type => this.visitType(type, q))
+            };
+            return (0, util_1.updateIfChanged)(ident, updates);
         });
     }
     visitSpace(space, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(space);
-            draft.comments = yield q.receiveListDefined(space.comments, (c) => __awaiter(this, void 0, void 0, function* () {
-                if (c.kind === tree_1.J.Kind.TextComment) {
-                    const tc = c;
-                    return yield (0, visitor_2.produceAsync)(tc, (draft) => __awaiter(this, void 0, void 0, function* () {
-                        draft.multiline = yield q.receive(tc.multiline);
-                        draft.text = yield q.receive(tc.text);
-                        draft.suffix = yield q.receive(c.suffix);
-                        draft.markers = yield q.receive(c.markers);
-                    }));
-                }
-                else {
-                    throw new Error(`Unexpected comment type ${c.kind}`);
-                }
-            }));
-            draft.whitespace = yield q.receive(space.whitespace);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                comments: yield q.receiveListDefined(space.comments, (c) => __awaiter(this, void 0, void 0, function* () {
+                    if (c.kind === tree_1.J.Kind.TextComment) {
+                        const tc = c;
+                        const commentUpdates = {
+                            multiline: yield q.receive(tc.multiline),
+                            text: yield q.receive(tc.text),
+                            suffix: yield q.receive(c.suffix),
+                            markers: yield q.receive(c.markers)
+                        };
+                        return (0, util_1.updateIfChanged)(tc, commentUpdates);
+                    }
+                    else {
+                        throw new Error(`Unexpected comment type ${c.kind}`);
+                    }
+                })),
+                whitespace: yield q.receive(space.whitespace)
+            };
+            return (0, util_1.updateIfChanged)(space, updates);
         });
     }
     visitLeftPadded(left, q) {
@@ -1341,20 +1677,21 @@ class JavaReceiver extends visitor_1.JavaVisitor {
             if (!left) {
                 throw new Error("TreeDataReceiveQueue should have instantiated an empty left padding");
             }
-            const draft = (0, immer_1.createDraft)(left);
-            draft.before = yield q.receive(left.before, space => this.visitSpace(space, q));
-            draft.element = (yield q.receive(left.element, elem => {
-                if ((0, tree_1.isSpace)(elem)) {
-                    return this.visitSpace(elem, q);
-                }
-                else if (typeof elem === 'object' && elem.kind) {
-                    // FIXME find a better way to check if it is a `Tree`
-                    return this.visit(elem, q);
-                }
-                return elem;
-            }));
-            draft.markers = yield q.receive(left.markers);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                before: yield q.receive(left.before, space => this.visitSpace(space, q)),
+                element: yield q.receive(left.element, elem => {
+                    if ((0, tree_1.isSpace)(elem)) {
+                        return this.visitSpace(elem, q);
+                    }
+                    else if (typeof elem === 'object' && elem.kind) {
+                        // FIXME find a better way to check if it is a `Tree`
+                        return this.visit(elem, q);
+                    }
+                    return elem;
+                }),
+                markers: yield q.receive(left.markers)
+            };
+            return (0, util_1.updateIfChanged)(left, updates);
         });
     }
     visitRightPadded(right, q) {
@@ -1362,45 +1699,47 @@ class JavaReceiver extends visitor_1.JavaVisitor {
             if (!right) {
                 throw new Error("TreeDataReceiveQueue should have instantiated an empty right padding");
             }
-            const draft = (0, immer_1.createDraft)(right);
-            draft.element = (yield q.receive(right.element, elem => {
-                if ((0, tree_1.isSpace)(elem)) {
-                    return this.visitSpace(elem, q);
-                }
-                else if (typeof elem === 'object' && elem.kind) {
-                    // FIXME find a better way to check if it is a `Tree`
-                    return this.visit(elem, q);
-                }
-                return elem;
-            }));
-            draft.after = yield q.receive(right.after, space => this.visitSpace(space, q));
-            draft.markers = yield q.receive(right.markers);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                element: yield q.receive(right.element, elem => {
+                    if ((0, tree_1.isSpace)(elem)) {
+                        return this.visitSpace(elem, q);
+                    }
+                    else if (typeof elem === 'object' && elem.kind) {
+                        // FIXME find a better way to check if it is a `Tree`
+                        return this.visit(elem, q);
+                    }
+                    return elem;
+                }),
+                after: yield q.receive(right.after, space => this.visitSpace(space, q)),
+                markers: yield q.receive(right.markers)
+            };
+            return (0, util_1.updateIfChanged)(right, updates);
         });
     }
     visitContainer(container, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const draft = (0, immer_1.createDraft)(container);
-            draft.before = yield q.receive(container.before, space => this.visitSpace(space, q));
-            draft.elements = (yield q.receiveListDefined(container.elements, elem => this.visitRightPadded(elem, q)));
-            draft.markers = yield q.receive(container.markers);
-            return (0, immer_1.finishDraft)(draft);
+            const updates = {
+                before: yield q.receive(container.before, space => this.visitSpace(space, q)),
+                elements: yield q.receiveListDefined(container.elements, elem => this.visitRightPadded(elem, q)),
+                markers: yield q.receive(container.markers)
+            };
+            return (0, util_1.updateIfChanged)(container, updates);
         });
     }
     visitType(javaType, q) {
         return __awaiter(this, void 0, void 0, function* () {
-            const codec = rpc_1.RpcCodecs.forInstance(javaType);
-            if (codec) {
-                return yield codec.rpcReceive(javaType, q);
+            if (!javaType) {
+                return undefined;
             }
-            if (javaType !== undefined) {
-                throw new Error("Missing codec for Type " + javaType.kind);
+            else if (javaType.kind === type_1.Type.Kind.Unknown) {
+                return type_1.Type.unknownType;
             }
-            return undefined;
+            return yield JavaReceiver.typeVisitor.visit(javaType, q);
         });
     }
 }
 exports.JavaReceiver = JavaReceiver;
+JavaReceiver.typeVisitor = new TypeReceiver();
 function registerJLanguageCodecs(sourceFileType, receiver, sender, extendedKinds) {
     const kinds = new Set([
         ...Object.values(tree_1.J.Kind),