@openrewrite/rewrite 8.63.0 → 8.63.2

package/dist/java/visitor.js

@@ -92,10 +92,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             annotatedType = expression;
-            return this.produceJava(annotatedType, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(annotatedType.annotations, a => this.visitDefined(a, p));
-                draft.typeExpression = (yield this.visitDefined(annotatedType.typeExpression, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(annotatedType.prefix, p),
+                markers: yield this.visitMarkers(annotatedType.markers, p),
+                annotations: yield (0, util_1.mapAsync)(annotatedType.annotations, a => this.visitDefined(a, p)),
+                typeExpression: yield this.visitDefined(annotatedType.typeExpression, p)
+            };
+            return (0, util_1.updateIfChanged)(annotatedType, updates);
         });
     }
     visitAnnotation(annotation, p) {
@@ -105,10 +108,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             annotation = expression;
-            return this.produceJava(annotation, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotationType = yield this.visitTypeName(annotation.annotationType, p);
-                draft.arguments = yield this.visitOptionalContainer(annotation.arguments, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(annotation.prefix, p),
+                markers: yield this.visitMarkers(annotation.markers, p),
+                annotationType: yield this.visitTypeName(annotation.annotationType, p),
+                arguments: yield this.visitOptionalContainer(annotation.arguments, p)
+            };
+            return (0, util_1.updateIfChanged)(annotation, updates);
         });
     }
     visitArrayAccess(arrayAccess, p) {
@@ -118,17 +124,23 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             arrayAccess = expression;
-            return this.produceJava(arrayAccess, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.indexed = (yield this.visitDefined(arrayAccess.indexed, p));
-                draft.dimension = (yield this.visitDefined(arrayAccess.dimension, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(arrayAccess.prefix, p),
+                markers: yield this.visitMarkers(arrayAccess.markers, p),
+                indexed: yield this.visitDefined(arrayAccess.indexed, p),
+                dimension: yield this.visitDefined(arrayAccess.dimension, p)
+            };
+            return (0, util_1.updateIfChanged)(arrayAccess, updates);
         });
     }
     visitArrayDimension(arrayDimension, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(arrayDimension, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.index = yield this.visitRightPadded(arrayDimension.index, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(arrayDimension.prefix, p),
+                markers: yield this.visitMarkers(arrayDimension.markers, p),
+                index: yield this.visitRightPadded(arrayDimension.index, p)
+            };
+            return (0, util_1.updateIfChanged)(arrayDimension, updates);
         });
     }
     visitArrayType(arrayType, p) {
@@ -138,14 +150,17 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             arrayType = expression;
-            return this.produceJava(arrayType, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.elementType = (yield this.visitDefined(arrayType.elementType, p));
-                if (arrayType.annotations) {
-                    draft.annotations = yield (0, util_1.mapAsync)(arrayType.annotations, a => this.visitDefined(a, p));
-                }
-                draft.dimension = yield this.visitLeftPadded(arrayType.dimension, p);
-                draft.type = yield this.visitType(arrayType.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(arrayType.prefix, p),
+                markers: yield this.visitMarkers(arrayType.markers, p),
+                elementType: yield this.visitDefined(arrayType.elementType, p),
+                dimension: yield this.visitLeftPadded(arrayType.dimension, p),
+                type: yield this.visitType(arrayType.type, p)
+            };
+            if (arrayType.annotations) {
+                updates.annotations = yield (0, util_1.mapAsync)(arrayType.annotations, a => this.visitDefined(a, p));
+            }
+            return (0, util_1.updateIfChanged)(arrayType, updates);
         });
     }
     visitAssert(anAssert, p) {
@@ -155,10 +170,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             anAssert = statement;
-            return this.produceJava(anAssert, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.condition = (yield this.visitDefined(anAssert.condition, p));
-                draft.detail = yield this.visitOptionalLeftPadded(anAssert.detail, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(anAssert.prefix, p),
+                markers: yield this.visitMarkers(anAssert.markers, p),
+                condition: yield this.visitDefined(anAssert.condition, p),
+                detail: yield this.visitOptionalLeftPadded(anAssert.detail, p)
+            };
+            return (0, util_1.updateIfChanged)(anAssert, updates);
         });
     }
     visitAssignment(assignment, p) {
@@ -173,11 +191,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             assignment = statement;
-            return this.produceJava(assignment, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.variable = (yield this.visitDefined(assignment.variable, p));
-                draft.assignment = yield this.visitLeftPadded(assignment.assignment, p);
-                draft.type = yield this.visitType(assignment.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(assignment.prefix, p),
+                markers: yield this.visitMarkers(assignment.markers, p),
+                variable: yield this.visitDefined(assignment.variable, p),
+                assignment: yield this.visitLeftPadded(assignment.assignment, p),
+                type: yield this.visitType(assignment.type, p)
+            };
+            return (0, util_1.updateIfChanged)(assignment, updates);
         });
     }
     visitAssignmentOperation(assignOp, p) {
@@ -187,12 +208,15 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             assignOp = expression;
-            return this.produceJava(assignOp, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.variable = (yield this.visitDefined(assignOp.variable, p));
-                draft.operator = yield this.visitLeftPadded(assignOp.operator, p);
-                draft.assignment = (yield this.visitDefined(assignOp.assignment, p));
-                draft.type = yield this.visitType(assignOp.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(assignOp.prefix, p),
+                markers: yield this.visitMarkers(assignOp.markers, p),
+                variable: yield this.visitDefined(assignOp.variable, p),
+                operator: yield this.visitLeftPadded(assignOp.operator, p),
+                assignment: yield this.visitDefined(assignOp.assignment, p),
+                type: yield this.visitType(assignOp.type, p)
+            };
+            return (0, util_1.updateIfChanged)(assignOp, updates);
         });
     }
     visitBinary(binary, p) {
@@ -202,21 +226,27 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             binary = expression;
-            return this.produceJava(binary, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.left = (yield this.visitDefined(binary.left, p));
-                draft.operator = yield this.visitLeftPadded(binary.operator, p);
-                draft.right = (yield this.visitDefined(binary.right, p));
-                draft.type = yield this.visitType(binary.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(binary.prefix, p),
+                markers: yield this.visitMarkers(binary.markers, p),
+                left: yield this.visitDefined(binary.left, p),
+                operator: yield this.visitLeftPadded(binary.operator, p),
+                right: yield this.visitDefined(binary.right, p),
+                type: yield this.visitType(binary.type, p)
+            };
+            return (0, util_1.updateIfChanged)(binary, updates);
         });
     }
     visitBlock(block, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(block, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.static = yield this.visitRightPadded(block.static, p);
-                draft.statements = yield (0, util_1.mapAsync)(block.statements, stmt => this.visitRightPadded(stmt, p));
-                draft.end = yield this.visitSpace(block.end, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(block.prefix, p),
+                markers: yield this.visitMarkers(block.markers, p),
+                static: yield this.visitRightPadded(block.static, p),
+                statements: yield (0, util_1.mapAsync)(block.statements, stmt => this.visitRightPadded(stmt, p)),
+                end: yield this.visitSpace(block.end, p)
+            };
+            return (0, util_1.updateIfChanged)(block, updates);
         });
     }
     visitBreak(breakStatement, p) {
@@ -226,11 +256,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             breakStatement = statement;
-            return this.produceJava(breakStatement, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (breakStatement.label) {
-                    draft.label = (yield this.visitDefined(breakStatement.label, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(breakStatement.prefix, p),
+                markers: yield this.visitMarkers(breakStatement.markers, p)
+            };
+            if (breakStatement.label) {
+                updates.label = (yield this.visitDefined(breakStatement.label, p));
+            }
+            return (0, util_1.updateIfChanged)(breakStatement, updates);
         });
     }
     visitCase(aCase, p) {
@@ -240,14 +273,17 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             aCase = statement;
-            return this.produceJava(aCase, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.caseLabels = yield this.visitContainer(aCase.caseLabels, p);
-                draft.statements = yield this.visitContainer(aCase.statements, p);
-                draft.body = yield this.visitOptionalRightPadded(aCase.body, p);
-                if (aCase.guard) {
-                    draft.guard = (yield this.visitDefined(aCase.guard, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(aCase.prefix, p),
+                markers: yield this.visitMarkers(aCase.markers, p),
+                caseLabels: yield this.visitContainer(aCase.caseLabels, p),
+                statements: yield this.visitContainer(aCase.statements, p),
+                body: yield this.visitOptionalRightPadded(aCase.body, p)
+            };
+            if (aCase.guard) {
+                updates.guard = (yield this.visitDefined(aCase.guard, p));
+            }
+            return (0, util_1.updateIfChanged)(aCase, updates);
         });
     }
     visitClassDeclaration(classDecl, p) {
@@ -257,36 +293,45 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             classDecl = statement;
-            return this.produceJava(classDecl, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.leadingAnnotations = yield (0, util_1.mapAsync)(classDecl.leadingAnnotations, a => this.visitDefined(a, p));
-                draft.modifiers = yield (0, util_1.mapAsync)(classDecl.modifiers, m => this.visitDefined(m, p));
-                draft.classKind = (yield this.visitDefined(classDecl.classKind, p));
-                draft.name = (yield this.visitDefined(classDecl.name, p));
-                draft.typeParameters = yield this.visitOptionalContainer(classDecl.typeParameters, p);
-                draft.primaryConstructor = yield this.visitOptionalContainer(classDecl.primaryConstructor, p);
-                draft.extends = yield this.visitOptionalLeftPadded(classDecl.extends, p);
-                draft.implements = yield this.visitOptionalContainer(classDecl.implements, p);
-                draft.permitting = yield this.visitOptionalContainer(classDecl.permitting, p);
-                draft.body = (yield this.visitDefined(classDecl.body, p));
-                draft.type = (yield this.visitType(classDecl.type, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(classDecl.prefix, p),
+                markers: yield this.visitMarkers(classDecl.markers, p),
+                leadingAnnotations: yield (0, util_1.mapAsync)(classDecl.leadingAnnotations, a => this.visitDefined(a, p)),
+                modifiers: yield (0, util_1.mapAsync)(classDecl.modifiers, m => this.visitDefined(m, p)),
+                classKind: yield this.visitDefined(classDecl.classKind, p),
+                name: yield this.visitDefined(classDecl.name, p),
+                typeParameters: yield this.visitOptionalContainer(classDecl.typeParameters, p),
+                primaryConstructor: yield this.visitOptionalContainer(classDecl.primaryConstructor, p),
+                extends: yield this.visitOptionalLeftPadded(classDecl.extends, p),
+                implements: yield this.visitOptionalContainer(classDecl.implements, p),
+                permitting: yield this.visitOptionalContainer(classDecl.permitting, p),
+                body: yield this.visitDefined(classDecl.body, p),
+                type: yield this.visitType(classDecl.type, p)
+            };
+            return (0, util_1.updateIfChanged)(classDecl, updates);
         });
     }
     visitClassDeclarationKind(kind, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(kind, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(kind.annotations, a => this.visitDefined(a, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(kind.prefix, p),
+                markers: yield this.visitMarkers(kind.markers, p),
+                annotations: yield (0, util_1.mapAsync)(kind.annotations, a => this.visitDefined(a, p))
+            };
+            return (0, util_1.updateIfChanged)(kind, updates);
         });
     }
     visitCompilationUnit(cu, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(cu, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.packageDeclaration = (yield this.visitRightPadded(cu.packageDeclaration, p));
-                draft.imports = yield (0, util_1.mapAsync)(cu.imports, imp => this.visitRightPadded(imp, p));
-                draft.classes = yield (0, util_1.mapAsync)(cu.classes, cls => this.visitDefined(cls, p));
-                draft.eof = yield this.visitSpace(cu.eof, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(cu.prefix, p),
+                markers: yield this.visitMarkers(cu.markers, p),
+                packageDeclaration: yield this.visitRightPadded(cu.packageDeclaration, p),
+                imports: yield (0, util_1.mapAsync)(cu.imports, imp => this.visitRightPadded(imp, p)),
+                classes: yield (0, util_1.mapAsync)(cu.classes, cls => this.visitDefined(cls, p)),
+                eof: yield this.visitSpace(cu.eof, p)
+            };
+            return (0, util_1.updateIfChanged)(cu, updates);
         });
     }
     visitContinue(continueStatement, p) {
@@ -296,27 +341,36 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             continueStatement = statement;
-            return this.produceJava(continueStatement, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (continueStatement.label) {
-                    draft.label = (yield this.visitDefined(continueStatement.label, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(continueStatement.prefix, p),
+                markers: yield this.visitMarkers(continueStatement.markers, p)
+            };
+            if (continueStatement.label) {
+                updates.label = (yield this.visitDefined(continueStatement.label, p));
+            }
+            return (0, util_1.updateIfChanged)(continueStatement, updates);
         });
     }
     visitControlParentheses(controlParens, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(controlParens, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.tree = yield this.visitRightPadded(controlParens.tree, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(controlParens.prefix, p),
+                markers: yield this.visitMarkers(controlParens.markers, p),
+                tree: yield this.visitRightPadded(controlParens.tree, p)
+            };
+            return (0, util_1.updateIfChanged)(controlParens, updates);
         });
     }
     visitDeconstructionPattern(pattern, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(pattern, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.deconstructor = (yield this.visitDefined(pattern.deconstructor, p));
-                draft.nested = yield this.visitContainer(pattern.nested, p);
-                draft.type = yield this.visitType(pattern.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(pattern.prefix, p),
+                markers: yield this.visitMarkers(pattern.markers, p),
+                deconstructor: yield this.visitDefined(pattern.deconstructor, p),
+                nested: yield this.visitContainer(pattern.nested, p),
+                type: yield this.visitType(pattern.type, p)
+            };
+            return (0, util_1.updateIfChanged)(pattern, updates);
         });
     }
     visitDoWhileLoop(doWhileLoop, p) {
@@ -326,10 +380,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             doWhileLoop = statement;
-            return this.produceJava(doWhileLoop, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.body = yield this.visitRightPadded(doWhileLoop.body, p);
-                draft.whileCondition = yield this.visitLeftPadded(doWhileLoop.whileCondition, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(doWhileLoop.prefix, p),
+                markers: yield this.visitMarkers(doWhileLoop.markers, p),
+                body: yield this.visitRightPadded(doWhileLoop.body, p),
+                whileCondition: yield this.visitLeftPadded(doWhileLoop.whileCondition, p)
+            };
+            return (0, util_1.updateIfChanged)(doWhileLoop, updates);
         });
     }
     visitEmpty(empty, p) {
@@ -344,18 +401,25 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             empty = statement;
-            return this.produceJava(empty, p);
+            const updates = {
+                prefix: yield this.visitSpace(empty.prefix, p),
+                markers: yield this.visitMarkers(empty.markers, p)
+            };
+            return (0, util_1.updateIfChanged)(empty, updates);
         });
     }
     visitEnumValue(enumValue, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(enumValue, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(enumValue.annotations, a => this.visitDefined(a, p));
-                draft.name = (yield this.visitDefined(enumValue.name, p));
-                if (enumValue.initializer) {
-                    draft.initializer = (yield this.visitDefined(enumValue.initializer, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(enumValue.prefix, p),
+                markers: yield this.visitMarkers(enumValue.markers, p),
+                annotations: yield (0, util_1.mapAsync)(enumValue.annotations, a => this.visitDefined(a, p)),
+                name: yield this.visitDefined(enumValue.name, p)
+            };
+            if (enumValue.initializer) {
+                updates.initializer = (yield this.visitDefined(enumValue.initializer, p));
+            }
+            return (0, util_1.updateIfChanged)(enumValue, updates);
         });
     }
     visitEnumValueSet(enumValueSet, p) {
@@ -365,9 +429,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             enumValueSet = statement;
-            return this.produceJava(enumValueSet, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.enums = yield (0, util_1.mapAsync)(enumValueSet.enums, e => this.visitRightPadded(e, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(enumValueSet.prefix, p),
+                markers: yield this.visitMarkers(enumValueSet.markers, p),
+                enums: yield (0, util_1.mapAsync)(enumValueSet.enums, e => this.visitRightPadded(e, p))
+            };
+            return (0, util_1.updateIfChanged)(enumValueSet, updates);
         });
     }
     visitErroneous(erroneous, p) {
@@ -382,7 +449,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             erroneous = statement;
-            return this.produceJava(erroneous, p);
+            const updates = {
+                prefix: yield this.visitSpace(erroneous.prefix, p),
+                markers: yield this.visitMarkers(erroneous.markers, p)
+            };
+            return (0, util_1.updateIfChanged)(erroneous, updates);
         });
     }
     visitFieldAccess(fieldAccess, p) {
@@ -397,11 +468,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             fieldAccess = statement;
-            return this.produceJava(fieldAccess, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.target = (yield this.visitDefined(fieldAccess.target, p));
-                draft.name = yield this.visitLeftPadded(fieldAccess.name, p);
-                draft.type = yield this.visitType(fieldAccess.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(fieldAccess.prefix, p),
+                markers: yield this.visitMarkers(fieldAccess.markers, p),
+                target: yield this.visitDefined(fieldAccess.target, p),
+                name: yield this.visitLeftPadded(fieldAccess.name, p),
+                type: yield this.visitType(fieldAccess.type, p)
+            };
+            return (0, util_1.updateIfChanged)(fieldAccess, updates);
         });
     }
     visitForEachLoop(forLoop, p) {
@@ -411,18 +485,24 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             forLoop = statement;
-            return this.produceJava(forLoop, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.control = (yield this.visitDefined(forLoop.control, p));
-                draft.body = yield this.visitRightPadded(forLoop.body, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(forLoop.prefix, p),
+                markers: yield this.visitMarkers(forLoop.markers, p),
+                control: yield this.visitDefined(forLoop.control, p),
+                body: yield this.visitRightPadded(forLoop.body, p)
+            };
+            return (0, util_1.updateIfChanged)(forLoop, updates);
         });
     }
     visitForEachLoopControl(control, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(control, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.variable = yield this.visitRightPadded(control.variable, p);
-                draft.iterable = yield this.visitRightPadded(control.iterable, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(control.prefix, p),
+                markers: yield this.visitMarkers(control.markers, p),
+                variable: yield this.visitRightPadded(control.variable, p),
+                iterable: yield this.visitRightPadded(control.iterable, p)
+            };
+            return (0, util_1.updateIfChanged)(control, updates);
         });
     }
     visitForLoop(forLoop, p) {
@@ -432,19 +512,25 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             forLoop = statement;
-            return this.produceJava(forLoop, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.control = (yield this.visitDefined(forLoop.control, p));
-                draft.body = yield this.visitRightPadded(forLoop.body, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(forLoop.prefix, p),
+                markers: yield this.visitMarkers(forLoop.markers, p),
+                control: yield this.visitDefined(forLoop.control, p),
+                body: yield this.visitRightPadded(forLoop.body, p)
+            };
+            return (0, util_1.updateIfChanged)(forLoop, updates);
         });
     }
     visitForLoopControl(control, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(control, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.init = yield (0, util_1.mapAsync)(control.init, i => this.visitRightPadded(i, p));
-                draft.condition = yield this.visitOptionalRightPadded(control.condition, p);
-                draft.update = yield (0, util_1.mapAsync)(control.update, u => this.visitRightPadded(u, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(control.prefix, p),
+                markers: yield this.visitMarkers(control.markers, p),
+                init: yield (0, util_1.mapAsync)(control.init, i => this.visitRightPadded(i, p)),
+                condition: yield this.visitOptionalRightPadded(control.condition, p),
+                update: yield (0, util_1.mapAsync)(control.update, u => this.visitRightPadded(u, p))
+            };
+            return (0, util_1.updateIfChanged)(control, updates);
         });
     }
     visitIdentifier(ident, p) {
@@ -454,11 +540,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             ident = expression;
-            return this.produceJava(ident, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(ident.annotations, a => this.visitDefined(a, p));
-                draft.type = yield this.visitType(ident.type, p);
-                draft.fieldType = (yield this.visitType(ident.fieldType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(ident.prefix, p),
+                markers: yield this.visitMarkers(ident.markers, p),
+                annotations: yield (0, util_1.mapAsync)(ident.annotations, a => this.visitDefined(a, p)),
+                type: yield this.visitType(ident.type, p),
+                fieldType: yield this.visitType(ident.fieldType, p)
+            };
+            return (0, util_1.updateIfChanged)(ident, updates);
         });
     }
     visitIf(iff, p) {
@@ -468,29 +557,38 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             iff = statement;
-            return this.produceJava(iff, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.ifCondition = (yield this.visitDefined(iff.ifCondition, p));
-                draft.thenPart = yield this.visitRightPadded(iff.thenPart, p);
-                if (iff.elsePart) {
-                    draft.elsePart = (yield this.visitDefined(iff.elsePart, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(iff.prefix, p),
+                markers: yield this.visitMarkers(iff.markers, p),
+                ifCondition: yield this.visitDefined(iff.ifCondition, p),
+                thenPart: yield this.visitRightPadded(iff.thenPart, p)
+            };
+            if (iff.elsePart) {
+                updates.elsePart = (yield this.visitDefined(iff.elsePart, p));
+            }
+            return (0, util_1.updateIfChanged)(iff, updates);
         });
     }
     visitElse(anElse, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(anElse, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.body = yield this.visitRightPadded(anElse.body, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(anElse.prefix, p),
+                markers: yield this.visitMarkers(anElse.markers, p),
+                body: yield this.visitRightPadded(anElse.body, p)
+            };
+            return (0, util_1.updateIfChanged)(anElse, updates);
         });
     }
     visitImport(anImport, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(anImport, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.static = yield this.visitLeftPadded(anImport.static, p);
-                draft.qualid = (yield this.visitDefined(anImport.qualid, p));
-                draft.alias = yield this.visitOptionalLeftPadded(anImport.alias, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(anImport.prefix, p),
+                markers: yield this.visitMarkers(anImport.markers, p),
+                static: yield this.visitLeftPadded(anImport.static, p),
+                qualid: yield this.visitDefined(anImport.qualid, p),
+                alias: yield this.visitOptionalLeftPadded(anImport.alias, p)
+            };
+            return (0, util_1.updateIfChanged)(anImport, updates);
         });
     }
     visitInstanceOf(instanceOf, p) {
@@ -500,17 +598,20 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             instanceOf = expression;
-            return this.produceJava(instanceOf, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.expression = yield this.visitRightPadded(instanceOf.expression, p);
-                draft.class = (yield this.visitDefined(instanceOf.class, p));
-                if (instanceOf.pattern) {
-                    draft.pattern = (yield this.visitDefined(instanceOf.pattern, p));
-                }
-                draft.type = yield this.visitType(instanceOf.type, p);
-                if (instanceOf.modifier) {
-                    draft.modifier = (yield this.visitDefined(instanceOf.modifier, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(instanceOf.prefix, p),
+                markers: yield this.visitMarkers(instanceOf.markers, p),
+                expression: yield this.visitRightPadded(instanceOf.expression, p),
+                class: yield this.visitDefined(instanceOf.class, p),
+                type: yield this.visitType(instanceOf.type, p)
+            };
+            if (instanceOf.pattern) {
+                updates.pattern = (yield this.visitDefined(instanceOf.pattern, p));
+            }
+            if (instanceOf.modifier) {
+                updates.modifier = (yield this.visitDefined(instanceOf.modifier, p));
+            }
+            return (0, util_1.updateIfChanged)(instanceOf, updates);
         });
     }
     visitIntersectionType(intersectionType, p) {
@@ -520,9 +621,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             intersectionType = expression;
-            return this.produceJava(intersectionType, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.bounds = yield this.visitContainer(intersectionType.bounds, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(intersectionType.prefix, p),
+                markers: yield this.visitMarkers(intersectionType.markers, p),
+                bounds: yield this.visitContainer(intersectionType.bounds, p)
+            };
+            return (0, util_1.updateIfChanged)(intersectionType, updates);
         });
     }
     visitLabel(label, p) {
@@ -532,10 +636,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             label = statement;
-            return this.produceJava(label, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.label = yield this.visitRightPadded(label.label, p);
-                draft.statement = (yield this.visitDefined(label.statement, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(label.prefix, p),
+                markers: yield this.visitMarkers(label.markers, p),
+                label: yield this.visitRightPadded(label.label, p),
+                statement: yield this.visitDefined(label.statement, p)
+            };
+            return (0, util_1.updateIfChanged)(label, updates);
         });
     }
     visitLambda(lambda, p) {
@@ -550,19 +657,25 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             lambda = statement;
-            return this.produceJava(lambda, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.parameters = (yield this.visitDefined(lambda.parameters, p));
-                draft.arrow = yield this.visitSpace(lambda.arrow, p);
-                draft.body = (yield this.visitDefined(lambda.body, p));
-                draft.type = yield this.visitType(lambda.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(lambda.prefix, p),
+                markers: yield this.visitMarkers(lambda.markers, p),
+                parameters: yield this.visitDefined(lambda.parameters, p),
+                arrow: yield this.visitSpace(lambda.arrow, p),
+                body: yield this.visitDefined(lambda.body, p),
+                type: yield this.visitType(lambda.type, p)
+            };
+            return (0, util_1.updateIfChanged)(lambda, updates);
         });
     }
     visitLambdaParameters(params, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(params, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.parameters = yield (0, util_1.mapAsync)(params.parameters, param => this.visitRightPadded(param, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(params.prefix, p),
+                markers: yield this.visitMarkers(params.markers, p),
+                parameters: yield (0, util_1.mapAsync)(params.parameters, param => this.visitRightPadded(param, p))
+            };
+            return (0, util_1.updateIfChanged)(params, updates);
         });
     }
     visitLiteral(literal, p) {
@@ -572,9 +685,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             literal = expression;
-            return this.produceJava(literal, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.type = (yield this.visitType(literal.type, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(literal.prefix, p),
+                markers: yield this.visitMarkers(literal.markers, p),
+                type: yield this.visitType(literal.type, p)
+            };
+            return (0, util_1.updateIfChanged)(literal, updates);
         });
     }
     visitMemberReference(memberRef, p) {
@@ -584,14 +700,17 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             memberRef = expression;
-            return this.produceJava(memberRef, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.containing = yield this.visitRightPadded(memberRef.containing, p);
-                draft.typeParameters = yield this.visitOptionalContainer(memberRef.typeParameters, p);
-                draft.reference = yield this.visitLeftPadded(memberRef.reference, p);
-                draft.type = yield this.visitType(memberRef.type, p);
-                draft.methodType = (yield this.visitType(memberRef.methodType, p));
-                draft.variableType = (yield this.visitType(memberRef.variableType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(memberRef.prefix, p),
+                markers: yield this.visitMarkers(memberRef.markers, p),
+                containing: yield this.visitRightPadded(memberRef.containing, p),
+                typeParameters: yield this.visitOptionalContainer(memberRef.typeParameters, p),
+                reference: yield this.visitLeftPadded(memberRef.reference, p),
+                type: yield this.visitType(memberRef.type, p),
+                methodType: yield this.visitType(memberRef.methodType, p),
+                variableType: yield this.visitType(memberRef.variableType, p)
+            };
+            return (0, util_1.updateIfChanged)(memberRef, updates);
         });
     }
     visitMethodDeclaration(method, p) {
@@ -601,23 +720,26 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             method = statement;
-            return this.produceJava(method, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.leadingAnnotations = yield (0, util_1.mapAsync)(method.leadingAnnotations, a => this.visitDefined(a, p));
-                draft.modifiers = yield (0, util_1.mapAsync)(method.modifiers, m => this.visitDefined(m, p));
-                if (method.typeParameters) {
-                    draft.typeParameters = (yield this.visitDefined(method.typeParameters, p));
-                }
-                if (method.returnTypeExpression) {
-                    draft.returnTypeExpression = (yield this.visitDefined(method.returnTypeExpression, p));
-                }
-                draft.nameAnnotations = yield (0, util_1.mapAsync)(method.nameAnnotations, a => this.visitDefined(a, p));
-                draft.name = yield this.visitDefined(method.name, p);
-                draft.parameters = yield this.visitContainer(method.parameters, p);
-                draft.throws = method.throws && (yield this.visitContainer(method.throws, p));
-                draft.body = method.body && (yield this.visitDefined(method.body, p));
-                draft.defaultValue = yield this.visitOptionalLeftPadded(method.defaultValue, p);
-                draft.methodType = (yield this.visitType(method.methodType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(method.prefix, p),
+                markers: yield this.visitMarkers(method.markers, p),
+                leadingAnnotations: yield (0, util_1.mapAsync)(method.leadingAnnotations, a => this.visitDefined(a, p)),
+                modifiers: yield (0, util_1.mapAsync)(method.modifiers, m => this.visitDefined(m, p)),
+                nameAnnotations: yield (0, util_1.mapAsync)(method.nameAnnotations, a => this.visitDefined(a, p)),
+                name: yield this.visitDefined(method.name, p),
+                parameters: yield this.visitContainer(method.parameters, p),
+                throws: method.throws && (yield this.visitContainer(method.throws, p)),
+                body: method.body && (yield this.visitDefined(method.body, p)),
+                defaultValue: yield this.visitOptionalLeftPadded(method.defaultValue, p),
+                methodType: yield this.visitType(method.methodType, p)
+            };
+            if (method.typeParameters) {
+                updates.typeParameters = (yield this.visitDefined(method.typeParameters, p));
+            }
+            if (method.returnTypeExpression) {
+                updates.returnTypeExpression = (yield this.visitDefined(method.returnTypeExpression, p));
+            }
+            return (0, util_1.updateIfChanged)(method, updates);
         });
     }
     visitMethodInvocation(method, p) {
@@ -632,27 +754,36 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             method = statement;
-            return this.produceJava(method, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.select = yield this.visitOptionalRightPadded(method.select, p);
-                draft.typeParameters = yield this.visitOptionalContainer(method.typeParameters, p);
-                draft.name = (yield this.visitDefined(method.name, p));
-                draft.arguments = yield this.visitContainer(method.arguments, p);
-                draft.methodType = (yield this.visitType(method.methodType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(method.prefix, p),
+                markers: yield this.visitMarkers(method.markers, p),
+                select: yield this.visitOptionalRightPadded(method.select, p),
+                typeParameters: yield this.visitOptionalContainer(method.typeParameters, p),
+                name: yield this.visitDefined(method.name, p),
+                arguments: yield this.visitContainer(method.arguments, p),
+                methodType: yield this.visitType(method.methodType, p)
+            };
+            return (0, util_1.updateIfChanged)(method, updates);
         });
     }
     visitModifier(modifier, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(modifier, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(modifier.annotations, a => this.visitDefined(a, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(modifier.prefix, p),
+                markers: yield this.visitMarkers(modifier.markers, p),
+                annotations: yield (0, util_1.mapAsync)(modifier.annotations, a => this.visitDefined(a, p))
+            };
+            return (0, util_1.updateIfChanged)(modifier, updates);
         });
     }
     visitMultiCatch(multiCatch, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(multiCatch, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.alternatives = yield (0, util_1.mapAsync)(multiCatch.alternatives, alt => this.visitRightPadded(alt, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(multiCatch.prefix, p),
+                markers: yield this.visitMarkers(multiCatch.markers, p),
+                alternatives: yield (0, util_1.mapAsync)(multiCatch.alternatives, alt => this.visitRightPadded(alt, p))
+            };
+            return (0, util_1.updateIfChanged)(multiCatch, updates);
         });
     }
     visitNewArray(newArray, p) {
@@ -662,14 +793,17 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             newArray = expression;
-            return this.produceJava(newArray, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (newArray.typeExpression) {
-                    draft.typeExpression = (yield this.visitDefined(newArray.typeExpression, p));
-                }
-                draft.dimensions = yield (0, util_1.mapAsync)(newArray.dimensions, dim => this.visitDefined(dim, p));
-                draft.initializer = yield this.visitOptionalContainer(newArray.initializer, p);
-                draft.type = yield this.visitType(newArray.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(newArray.prefix, p),
+                markers: yield this.visitMarkers(newArray.markers, p),
+                dimensions: yield (0, util_1.mapAsync)(newArray.dimensions, dim => this.visitDefined(dim, p)),
+                initializer: yield this.visitOptionalContainer(newArray.initializer, p),
+                type: yield this.visitType(newArray.type, p)
+            };
+            if (newArray.typeExpression) {
+                updates.typeExpression = (yield this.visitDefined(newArray.typeExpression, p));
+            }
+            return (0, util_1.updateIfChanged)(newArray, updates);
         });
     }
     visitNewClass(newClass, p) {
@@ -679,20 +813,23 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             newClass = expression;
-            return this.produceJava(newClass, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (newClass.enclosing) {
-                    draft.enclosing = yield this.visitRightPadded(newClass.enclosing, p);
-                }
-                draft.new = yield this.visitSpace(newClass.new, p);
-                if (newClass.class) {
-                    draft.class = (yield this.visitDefined(newClass.class, p));
-                }
-                draft.arguments = yield this.visitContainer(newClass.arguments, p);
-                if (newClass.body) {
-                    draft.body = (yield this.visitDefined(newClass.body, p));
-                }
-                draft.constructorType = (yield this.visitType(newClass.constructorType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(newClass.prefix, p),
+                markers: yield this.visitMarkers(newClass.markers, p),
+                new: yield this.visitSpace(newClass.new, p),
+                arguments: yield this.visitContainer(newClass.arguments, p),
+                constructorType: yield this.visitType(newClass.constructorType, p)
+            };
+            if (newClass.enclosing) {
+                updates.enclosing = yield this.visitRightPadded(newClass.enclosing, p);
+            }
+            if (newClass.class) {
+                updates.class = (yield this.visitDefined(newClass.class, p));
+            }
+            if (newClass.body) {
+                updates.body = (yield this.visitDefined(newClass.body, p));
+            }
+            return (0, util_1.updateIfChanged)(newClass, updates);
         });
     }
     visitNullableType(nullableType, p) {
@@ -702,36 +839,48 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             nullableType = expression;
-            return this.produceJava(nullableType, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(nullableType.annotations, a => this.visitDefined(a, p));
-                draft.typeTree = yield this.visitRightPadded(nullableType.typeTree, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(nullableType.prefix, p),
+                markers: yield this.visitMarkers(nullableType.markers, p),
+                annotations: yield (0, util_1.mapAsync)(nullableType.annotations, a => this.visitDefined(a, p)),
+                typeTree: yield this.visitRightPadded(nullableType.typeTree, p)
+            };
+            return (0, util_1.updateIfChanged)(nullableType, updates);
         });
     }
     visitPackage(aPackage, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(aPackage, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.expression = (yield this.visitDefined(aPackage.expression, p));
-                if (aPackage.annotations) {
-                    draft.annotations = yield (0, util_1.mapAsync)(aPackage.annotations, a => this.visitDefined(a, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(aPackage.prefix, p),
+                markers: yield this.visitMarkers(aPackage.markers, p),
+                expression: yield this.visitDefined(aPackage.expression, p)
+            };
+            if (aPackage.annotations) {
+                updates.annotations = yield (0, util_1.mapAsync)(aPackage.annotations, a => this.visitDefined(a, p));
+            }
+            return (0, util_1.updateIfChanged)(aPackage, updates);
         });
     }
     visitParameterizedType(parameterizedType, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(parameterizedType, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.class = yield this.visitTypeName(parameterizedType.class, p);
-                draft.typeParameters = yield this.visitOptionalContainer(parameterizedType.typeParameters, p);
-                draft.type = yield this.visitType(parameterizedType.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(parameterizedType.prefix, p),
+                markers: yield this.visitMarkers(parameterizedType.markers, p),
+                class: yield this.visitTypeName(parameterizedType.class, p),
+                typeParameters: yield this.visitOptionalContainer(parameterizedType.typeParameters, p),
+                type: yield this.visitType(parameterizedType.type, p)
+            };
+            return (0, util_1.updateIfChanged)(parameterizedType, updates);
         });
     }
     visitParentheses(parentheses, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(parentheses, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.tree = yield this.visitRightPadded(parentheses.tree, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(parentheses.prefix, p),
+                markers: yield this.visitMarkers(parentheses.markers, p),
+                tree: yield this.visitRightPadded(parentheses.tree, p)
+            };
+            return (0, util_1.updateIfChanged)(parentheses, updates);
         });
     }
     visitParenthesizedTypeTree(parTypeTree, p) {
@@ -741,10 +890,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             parTypeTree = expression;
-            return this.produceJava(parTypeTree, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(parTypeTree.annotations, a => this.visitDefined(a, p));
-                draft.parenthesizedType = (yield this.visitDefined(parTypeTree.parenthesizedType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(parTypeTree.prefix, p),
+                markers: yield this.visitMarkers(parTypeTree.markers, p),
+                annotations: yield (0, util_1.mapAsync)(parTypeTree.annotations, a => this.visitDefined(a, p)),
+                parenthesizedType: yield this.visitDefined(parTypeTree.parenthesizedType, p)
+            };
+            return (0, util_1.updateIfChanged)(parTypeTree, updates);
         });
     }
     visitPrimitive(primitive, p) {
@@ -754,9 +906,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             primitive = expression;
-            return this.produceJava(primitive, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.type = (yield this.visitType(primitive.type, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(primitive.prefix, p),
+                markers: yield this.visitMarkers(primitive.markers, p),
+                type: yield this.visitType(primitive.type, p)
+            };
+            return (0, util_1.updateIfChanged)(primitive, updates);
         });
     }
     visitReturn(ret, p) {
@@ -766,11 +921,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             ret = statement;
-            return this.produceJava(ret, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                if (ret.expression) {
-                    draft.expression = (yield this.visitDefined(ret.expression, p));
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(ret.prefix, p),
+                markers: yield this.visitMarkers(ret.markers, p)
+            };
+            if (ret.expression) {
+                updates.expression = (yield this.visitDefined(ret.expression, p));
+            }
+            return (0, util_1.updateIfChanged)(ret, updates);
         });
     }
     visitSwitch(aSwitch, p) {
@@ -780,10 +938,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             aSwitch = statement;
-            return this.produceJava(aSwitch, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.selector = (yield this.visitDefined(aSwitch.selector, p));
-                draft.cases = (yield this.visitDefined(aSwitch.cases, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(aSwitch.prefix, p),
+                markers: yield this.visitMarkers(aSwitch.markers, p),
+                selector: yield this.visitDefined(aSwitch.selector, p),
+                cases: yield this.visitDefined(aSwitch.cases, p)
+            };
+            return (0, util_1.updateIfChanged)(aSwitch, updates);
         });
     }
     visitSwitchExpression(switchExpr, p) {
@@ -793,11 +954,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             switchExpr = expression;
-            return this.produceJava(switchExpr, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.selector = (yield this.visitDefined(switchExpr.selector, p));
-                draft.cases = (yield this.visitDefined(switchExpr.cases, p));
-                draft.type = yield this.visitType(switchExpr.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(switchExpr.prefix, p),
+                markers: yield this.visitMarkers(switchExpr.markers, p),
+                selector: yield this.visitDefined(switchExpr.selector, p),
+                cases: yield this.visitDefined(switchExpr.cases, p),
+                type: yield this.visitType(switchExpr.type, p)
+            };
+            return (0, util_1.updateIfChanged)(switchExpr, updates);
         });
     }
     visitSynchronized(sync, p) {
@@ -807,10 +971,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             sync = statement;
-            return this.produceJava(sync, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.lock = (yield this.visitDefined(sync.lock, p));
-                draft.body = (yield this.visitDefined(sync.body, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(sync.prefix, p),
+                markers: yield this.visitMarkers(sync.markers, p),
+                lock: yield this.visitDefined(sync.lock, p),
+                body: yield this.visitDefined(sync.body, p)
+            };
+            return (0, util_1.updateIfChanged)(sync, updates);
         });
     }
     visitTernary(ternary, p) {
@@ -825,12 +992,15 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             ternary = statement;
-            return this.produceJava(ternary, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.condition = (yield this.visitDefined(ternary.condition, p));
-                draft.truePart = yield this.visitLeftPadded(ternary.truePart, p);
-                draft.falsePart = yield this.visitLeftPadded(ternary.falsePart, p);
-                draft.type = yield this.visitType(ternary.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(ternary.prefix, p),
+                markers: yield this.visitMarkers(ternary.markers, p),
+                condition: yield this.visitDefined(ternary.condition, p),
+                truePart: yield this.visitLeftPadded(ternary.truePart, p),
+                falsePart: yield this.visitLeftPadded(ternary.falsePart, p),
+                type: yield this.visitType(ternary.type, p)
+            };
+            return (0, util_1.updateIfChanged)(ternary, updates);
         });
     }
     visitThrow(thrown, p) {
@@ -840,9 +1010,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             thrown = statement;
-            return this.produceJava(thrown, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.exception = (yield this.visitDefined(thrown.exception, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(thrown.prefix, p),
+                markers: yield this.visitMarkers(thrown.markers, p),
+                exception: yield this.visitDefined(thrown.exception, p)
+            };
+            return (0, util_1.updateIfChanged)(thrown, updates);
         });
     }
     visitTry(tryable, p) {
@@ -852,27 +1025,36 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             tryable = statement;
-            return this.produceJava(tryable, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.resources = yield this.visitOptionalContainer(tryable.resources, p);
-                draft.body = (yield this.visitDefined(tryable.body, p));
-                draft.catches = yield (0, util_1.mapAsync)(tryable.catches, c => this.visitDefined(c, p));
-                draft.finally = yield this.visitOptionalLeftPadded(tryable.finally, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(tryable.prefix, p),
+                markers: yield this.visitMarkers(tryable.markers, p),
+                resources: yield this.visitOptionalContainer(tryable.resources, p),
+                body: yield this.visitDefined(tryable.body, p),
+                catches: yield (0, util_1.mapAsync)(tryable.catches, c => this.visitDefined(c, p)),
+                finally: yield this.visitOptionalLeftPadded(tryable.finally, p)
+            };
+            return (0, util_1.updateIfChanged)(tryable, updates);
         });
     }
     visitTryResource(resource, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(resource, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.variableDeclarations = (yield this.visitDefined(resource.variableDeclarations, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(resource.prefix, p),
+                markers: yield this.visitMarkers(resource.markers, p),
+                variableDeclarations: yield this.visitDefined(resource.variableDeclarations, p)
+            };
+            return (0, util_1.updateIfChanged)(resource, updates);
         });
     }
     visitTryCatch(tryCatch, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(tryCatch, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.parameter = (yield this.visitDefined(tryCatch.parameter, p));
-                draft.body = (yield this.visitDefined(tryCatch.body, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(tryCatch.prefix, p),
+                markers: yield this.visitMarkers(tryCatch.markers, p),
+                parameter: yield this.visitDefined(tryCatch.parameter, p),
+                body: yield this.visitDefined(tryCatch.body, p)
+            };
+            return (0, util_1.updateIfChanged)(tryCatch, updates);
         });
     }
     visitTypeCast(typeCast, p) {
@@ -882,28 +1064,37 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             typeCast = expression;
-            return this.produceJava(typeCast, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.class = (yield this.visitDefined(typeCast.class, p));
-                draft.expression = (yield this.visitDefined(typeCast.expression, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(typeCast.prefix, p),
+                markers: yield this.visitMarkers(typeCast.markers, p),
+                class: yield this.visitDefined(typeCast.class, p),
+                expression: yield this.visitDefined(typeCast.expression, p)
+            };
+            return (0, util_1.updateIfChanged)(typeCast, updates);
         });
     }
     visitTypeParameter(typeParam, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(typeParam, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(typeParam.annotations, a => this.visitDefined(a, p));
-                draft.modifiers = yield (0, util_1.mapAsync)(typeParam.modifiers, m => this.visitDefined(m, p));
-                draft.name = (yield this.visitDefined(typeParam.name, p));
-                draft.bounds = yield this.visitOptionalContainer(typeParam.bounds, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(typeParam.prefix, p),
+                markers: yield this.visitMarkers(typeParam.markers, p),
+                annotations: yield (0, util_1.mapAsync)(typeParam.annotations, a => this.visitDefined(a, p)),
+                modifiers: yield (0, util_1.mapAsync)(typeParam.modifiers, m => this.visitDefined(m, p)),
+                name: yield this.visitDefined(typeParam.name, p),
+                bounds: yield this.visitOptionalContainer(typeParam.bounds, p)
+            };
+            return (0, util_1.updateIfChanged)(typeParam, updates);
         });
     }
     visitTypeParameters(typeParams, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(typeParams, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.annotations = yield (0, util_1.mapAsync)(typeParams.annotations, a => this.visitDefined(a, p));
-                draft.typeParameters = yield (0, util_1.mapAsync)(typeParams.typeParameters, tp => this.visitRightPadded(tp, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(typeParams.prefix, p),
+                markers: yield this.visitMarkers(typeParams.markers, p),
+                annotations: yield (0, util_1.mapAsync)(typeParams.annotations, a => this.visitDefined(a, p)),
+                typeParameters: yield (0, util_1.mapAsync)(typeParams.typeParameters, tp => this.visitRightPadded(tp, p))
+            };
+            return (0, util_1.updateIfChanged)(typeParams, updates);
         });
     }
     visitUnary(unary, p) {
@@ -918,11 +1109,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             unary = statement;
-            return this.produceJava(unary, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.operator = yield this.visitLeftPadded(unary.operator, p);
-                draft.expression = (yield this.visitDefined(unary.expression, p));
-                draft.type = yield this.visitType(unary.type, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(unary.prefix, p),
+                markers: yield this.visitMarkers(unary.markers, p),
+                operator: yield this.visitLeftPadded(unary.operator, p),
+                expression: yield this.visitDefined(unary.expression, p),
+                type: yield this.visitType(unary.type, p)
+            };
+            return (0, util_1.updateIfChanged)(unary, updates);
         });
     }
     visitUnknown(unknown, p) {
@@ -937,14 +1131,21 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             unknown = statement;
-            return this.produceJava(unknown, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.source = (yield this.visitDefined(unknown.source, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(unknown.prefix, p),
+                markers: yield this.visitMarkers(unknown.markers, p),
+                source: yield this.visitDefined(unknown.source, p)
+            };
+            return (0, util_1.updateIfChanged)(unknown, updates);
         });
     }
     visitUnknownSource(source, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(source, p);
+            const updates = {
+                prefix: yield this.visitSpace(source.prefix, p),
+                markers: yield this.visitMarkers(source.markers, p)
+            };
+            return (0, util_1.updateIfChanged)(source, updates);
         });
     }
     visitVariableDeclarations(varDecls, p) {
@@ -954,27 +1155,33 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             varDecls = statement;
-            return this.produceJava(varDecls, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.leadingAnnotations = yield (0, util_1.mapAsync)(varDecls.leadingAnnotations, a => this.visitDefined(a, p));
-                draft.modifiers = yield (0, util_1.mapAsync)(varDecls.modifiers, m => this.visitDefined(m, p));
-                if (varDecls.typeExpression) {
-                    draft.typeExpression = (yield this.visitDefined(varDecls.typeExpression, p));
-                }
-                if (varDecls.varargs) {
-                    draft.varargs = yield this.visitSpace(varDecls.varargs, p);
-                }
-                draft.variables = yield (0, util_1.mapAsync)(varDecls.variables, v => this.visitRightPadded(v, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(varDecls.prefix, p),
+                markers: yield this.visitMarkers(varDecls.markers, p),
+                leadingAnnotations: yield (0, util_1.mapAsync)(varDecls.leadingAnnotations, a => this.visitDefined(a, p)),
+                modifiers: yield (0, util_1.mapAsync)(varDecls.modifiers, m => this.visitDefined(m, p)),
+                variables: yield (0, util_1.mapAsync)(varDecls.variables, v => this.visitRightPadded(v, p))
+            };
+            if (varDecls.typeExpression) {
+                updates.typeExpression = (yield this.visitDefined(varDecls.typeExpression, p));
+            }
+            if (varDecls.varargs) {
+                updates.varargs = yield this.visitSpace(varDecls.varargs, p);
+            }
+            return (0, util_1.updateIfChanged)(varDecls, updates);
         });
     }
     visitVariable(variable, p) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.produceJava(variable, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.name = (yield this.visitDefined(variable.name, p));
-                draft.dimensionsAfterName = yield (0, util_1.mapAsync)(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, p));
-                draft.initializer = yield this.visitOptionalLeftPadded(variable.initializer, p);
-                draft.variableType = (yield this.visitType(variable.variableType, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(variable.prefix, p),
+                markers: yield this.visitMarkers(variable.markers, p),
+                name: yield this.visitDefined(variable.name, p),
+                dimensionsAfterName: yield (0, util_1.mapAsync)(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, p)),
+                initializer: yield this.visitOptionalLeftPadded(variable.initializer, p),
+                variableType: yield this.visitType(variable.variableType, p)
+            };
+            return (0, util_1.updateIfChanged)(variable, updates);
         });
     }
     visitWhileLoop(whileLoop, p) {
@@ -984,10 +1191,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             whileLoop = statement;
-            return this.produceJava(whileLoop, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.condition = (yield this.visitDefined(whileLoop.condition, p));
-                draft.body = yield this.visitRightPadded(whileLoop.body, p);
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(whileLoop.prefix, p),
+                markers: yield this.visitMarkers(whileLoop.markers, p),
+                condition: yield this.visitDefined(whileLoop.condition, p),
+                body: yield this.visitRightPadded(whileLoop.body, p)
+            };
+            return (0, util_1.updateIfChanged)(whileLoop, updates);
         });
     }
     visitWildcard(wildcard, p) {
@@ -997,12 +1207,15 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return expression;
             }
             wildcard = expression;
-            return this.produceJava(wildcard, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.bound = yield this.visitOptionalLeftPadded(wildcard.bound, p);
-                if (wildcard.boundedType) {
-                    draft.boundedType = yield this.visitTypeName(wildcard.boundedType, p);
-                }
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(wildcard.prefix, p),
+                markers: yield this.visitMarkers(wildcard.markers, p),
+                bound: yield this.visitOptionalLeftPadded(wildcard.bound, p)
+            };
+            if (wildcard.boundedType) {
+                updates.boundedType = yield this.visitTypeName(wildcard.boundedType, p);
+            }
+            return (0, util_1.updateIfChanged)(wildcard, updates);
         });
     }
     visitYield(aYield, p) {
@@ -1012,9 +1225,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
                 return statement;
             }
             aYield = statement;
-            return this.produceJava(aYield, p, (draft) => __awaiter(this, void 0, void 0, function* () {
-                draft.value = (yield this.visitDefined(aYield.value, p));
-            }));
+            const updates = {
+                prefix: yield this.visitSpace(aYield.prefix, p),
+                markers: yield this.visitMarkers(aYield.markers, p),
+                value: yield this.visitDefined(aYield.value, p)
+            };
+            return (0, util_1.updateIfChanged)(aYield, updates);
         });
     }
     visitOptionalRightPadded(right, p) {