@openrewrite/rewrite 8.96.5 → 8.97.0

package/dist/java/visitor.js

@@ -64,18 +64,36 @@ class JavaVisitor extends visitor_1.TreeVisitor {
     async visitTypeName(nameTree, p) {
         return nameTree;
     }
+    /**
+     * Visits the children of `tree` through `visit` under a cursor that holds it, where a visit made it of the tree
+     * on the cursor, and puts the given cursor back after with the messages they left.
+     */
+    visitChildrenOf(tree, visit) {
+        var _a;
+        const given = this.cursor;
+        if (given.value === tree || ((_a = given.value) === null || _a === void 0 ? void 0 : _a.kind) !== tree.kind) {
+            return visit();
+        }
+        this.cursor = new tree_1.Cursor(tree, given.parent);
+        given.messages.forEach((value, key) => this.cursor.messages.set(key, value));
+        return visit().then(visited => {
+            this.cursor.messages.forEach((value, key) => given.messages.set(key, value));
+            this.cursor = given;
+            return visited;
+        });
+    }
     async visitAnnotatedType(annotatedType, p) {
         const expression = await this.visitExpression(annotatedType, p);
         if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.AnnotatedType) {
             return expression;
         }
         annotatedType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(annotatedType, async () => ({
             prefix: await this.visitSpace(annotatedType.prefix, p),
             markers: await this.visitMarkers(annotatedType.markers, p),
             annotations: await (0, util_1.mapAsync)(annotatedType.annotations, a => this.visitDefined(a, p)),
             typeExpression: await this.visitDefined(annotatedType.typeExpression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(annotatedType, updates);
     }
     async visitAnnotation(annotation, p) {
@@ -84,12 +102,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         annotation = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(annotation, async () => ({
             prefix: await this.visitSpace(annotation.prefix, p),
             markers: await this.visitMarkers(annotation.markers, p),
             annotationType: await this.visitTypeName(annotation.annotationType, p),
             arguments: await this.visitOptionalContainer(annotation.arguments, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(annotation, updates);
     }
     async visitArrayAccess(arrayAccess, p) {
@@ -98,12 +116,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         arrayAccess = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(arrayAccess, async () => ({
             prefix: await this.visitSpace(arrayAccess.prefix, p),
             markers: await this.visitMarkers(arrayAccess.markers, p),
             indexed: await this.visitDefined(arrayAccess.indexed, p),
             dimension: await this.visitDefined(arrayAccess.dimension, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(arrayAccess, updates);
     }
     async visitArrayDimension(arrayDimension, p) {
@@ -120,17 +138,19 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         arrayType = expression;
-        const updates = {
-            prefix: await this.visitSpace(arrayType.prefix, p),
-            markers: await this.visitMarkers(arrayType.markers, p),
-            elementType: await this.visitDefined(arrayType.elementType, p),
-            dimension: await this.visitLeftPadded(arrayType.dimension, p),
-            type: await this.visitType(arrayType.type, p)
-        };
-        if (arrayType.annotations) {
-            updates.annotations = await (0, util_1.mapAsync)(arrayType.annotations, a => this.visitDefined(a, p));
-        }
-        return (0, util_1.updateIfChanged)(arrayType, updates);
+        return this.visitChildrenOf(arrayType, async () => {
+            const updates = {
+                prefix: await this.visitSpace(arrayType.prefix, p),
+                markers: await this.visitMarkers(arrayType.markers, p),
+                elementType: await this.visitDefined(arrayType.elementType, p),
+                dimension: await this.visitLeftPadded(arrayType.dimension, p),
+                type: await this.visitType(arrayType.type, p)
+            };
+            if (arrayType.annotations) {
+                updates.annotations = await (0, util_1.mapAsync)(arrayType.annotations, a => this.visitDefined(a, p));
+            }
+            return (0, util_1.updateIfChanged)(arrayType, updates);
+        });
     }
     async visitAssert(anAssert, p) {
         const statement = await this.visitStatement(anAssert, p);
@@ -138,12 +158,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         anAssert = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(anAssert, async () => ({
             prefix: await this.visitSpace(anAssert.prefix, p),
             markers: await this.visitMarkers(anAssert.markers, p),
             condition: await this.visitDefined(anAssert.condition, p),
             detail: await this.visitOptionalLeftPadded(anAssert.detail, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(anAssert, updates);
     }
     async visitAssignment(assignment, p) {
@@ -157,13 +177,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         assignment = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(assignment, async () => ({
             prefix: await this.visitSpace(assignment.prefix, p),
             markers: await this.visitMarkers(assignment.markers, p),
             variable: await this.visitDefined(assignment.variable, p),
             assignment: await this.visitLeftPadded(assignment.assignment, p),
             type: await this.visitType(assignment.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(assignment, updates);
     }
     async visitAssignmentOperation(assignOp, p) {
@@ -177,14 +197,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         assignOp = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(assignOp, async () => ({
             prefix: await this.visitSpace(assignOp.prefix, p),
             markers: await this.visitMarkers(assignOp.markers, p),
             variable: await this.visitDefined(assignOp.variable, p),
             operator: await this.visitLeftPadded(assignOp.operator, p),
             assignment: await this.visitDefined(assignOp.assignment, p),
             type: await this.visitType(assignOp.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(assignOp, updates);
     }
     async visitBinary(binary, p) {
@@ -192,26 +212,15 @@ class JavaVisitor extends visitor_1.TreeVisitor {
         if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Binary) {
             return expression;
         }
-        const given = this.cursor;
-        if (expression !== binary && given.value === binary) {
-            // the operands are visited under the binary that holds them, where a template reads their slots
-            this.cursor = new tree_1.Cursor(expression, given.parent);
-            given.messages.forEach((value, key) => this.cursor.messages.set(key, value));
-        }
         binary = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(binary, async () => ({
             prefix: await this.visitSpace(binary.prefix, p),
             markers: await this.visitMarkers(binary.markers, p),
             left: await this.visitDefined(binary.left, p),
             operator: await this.visitLeftPadded(binary.operator, p),
             right: await this.visitDefined(binary.right, p),
             type: await this.visitType(binary.type, p)
-        };
-        if (this.cursor !== given) {
-            // what follows reads the cursor of the binary it was given, as for every other tree
-            this.cursor.messages.forEach((value, key) => given.messages.set(key, value));
-            this.cursor = given;
-        }
+        }));
         return (0, util_1.updateIfChanged)(binary, updates);
     }
     async visitBlock(block, p) {
@@ -220,13 +229,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         block = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(block, async () => ({
             prefix: await this.visitSpace(block.prefix, p),
             markers: await this.visitMarkers(block.markers, p),
             static: await this.visitRightPadded(block.static, p),
             statements: await (0, util_1.mapAsync)(block.statements, stmt => this.visitRightPadded(stmt, p)),
             end: await this.visitSpace(block.end, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(block, updates);
     }
     async visitBreak(breakStatement, p) {
@@ -235,14 +244,16 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         breakStatement = statement;
-        const updates = {
-            prefix: await this.visitSpace(breakStatement.prefix, p),
-            markers: await this.visitMarkers(breakStatement.markers, p)
-        };
-        if (breakStatement.label) {
-            updates.label = await this.visitDefined(breakStatement.label, p);
-        }
-        return (0, util_1.updateIfChanged)(breakStatement, updates);
+        return this.visitChildrenOf(breakStatement, async () => {
+            const updates = {
+                prefix: await this.visitSpace(breakStatement.prefix, p),
+                markers: await this.visitMarkers(breakStatement.markers, p)
+            };
+            if (breakStatement.label) {
+                updates.label = await this.visitDefined(breakStatement.label, p);
+            }
+            return (0, util_1.updateIfChanged)(breakStatement, updates);
+        });
     }
     async visitCase(aCase, p) {
         const statement = await this.visitStatement(aCase, p);
@@ -250,17 +261,19 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         aCase = statement;
-        const updates = {
-            prefix: await this.visitSpace(aCase.prefix, p),
-            markers: await this.visitMarkers(aCase.markers, p),
-            caseLabels: await this.visitContainer(aCase.caseLabels, p),
-            statements: await this.visitContainer(aCase.statements, p),
-            body: await this.visitOptionalRightPadded(aCase.body, p)
-        };
-        if (aCase.guard) {
-            updates.guard = await this.visitDefined(aCase.guard, p);
-        }
-        return (0, util_1.updateIfChanged)(aCase, updates);
+        return this.visitChildrenOf(aCase, async () => {
+            const updates = {
+                prefix: await this.visitSpace(aCase.prefix, p),
+                markers: await this.visitMarkers(aCase.markers, p),
+                caseLabels: await this.visitContainer(aCase.caseLabels, p),
+                statements: await this.visitContainer(aCase.statements, p),
+                body: await this.visitOptionalRightPadded(aCase.body, p)
+            };
+            if (aCase.guard) {
+                updates.guard = await this.visitDefined(aCase.guard, p);
+            }
+            return (0, util_1.updateIfChanged)(aCase, updates);
+        });
     }
     async visitClassDeclaration(classDecl, p) {
         const statement = await this.visitStatement(classDecl, p);
@@ -268,7 +281,7 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         classDecl = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(classDecl, async () => ({
             prefix: await this.visitSpace(classDecl.prefix, p),
             markers: await this.visitMarkers(classDecl.markers, p),
             leadingAnnotations: await (0, util_1.mapAsync)(classDecl.leadingAnnotations, a => this.visitDefined(a, p)),
@@ -282,7 +295,7 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             permitting: await this.visitOptionalContainer(classDecl.permitting, p),
             body: await this.visitDefined(classDecl.body, p),
             type: await this.visitType(classDecl.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(classDecl, updates);
     }
     async visitClassDeclarationKind(kind, p) {
@@ -310,14 +323,16 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         continueStatement = statement;
-        const updates = {
-            prefix: await this.visitSpace(continueStatement.prefix, p),
-            markers: await this.visitMarkers(continueStatement.markers, p)
-        };
-        if (continueStatement.label) {
-            updates.label = await this.visitDefined(continueStatement.label, p);
-        }
-        return (0, util_1.updateIfChanged)(continueStatement, updates);
+        return this.visitChildrenOf(continueStatement, async () => {
+            const updates = {
+                prefix: await this.visitSpace(continueStatement.prefix, p),
+                markers: await this.visitMarkers(continueStatement.markers, p)
+            };
+            if (continueStatement.label) {
+                updates.label = await this.visitDefined(continueStatement.label, p);
+            }
+            return (0, util_1.updateIfChanged)(continueStatement, updates);
+        });
     }
     async visitControlParentheses(controlParens, p) {
         const expression = await this.visitExpression(controlParens, p);
@@ -325,11 +340,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         controlParens = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(controlParens, async () => ({
             prefix: await this.visitSpace(controlParens.prefix, p),
             markers: await this.visitMarkers(controlParens.markers, p),
             tree: await this.visitRightPadded(controlParens.tree, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(controlParens, updates);
     }
     async visitDeconstructionPattern(pattern, p) {
@@ -348,12 +363,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         doWhileLoop = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(doWhileLoop, async () => ({
             prefix: await this.visitSpace(doWhileLoop.prefix, p),
             markers: await this.visitMarkers(doWhileLoop.markers, p),
             body: await this.visitRightPadded(doWhileLoop.body, p),
             whileCondition: await this.visitLeftPadded(doWhileLoop.whileCondition, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(doWhileLoop, updates);
     }
     async visitEmpty(empty, p) {
@@ -391,11 +406,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         enumValueSet = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(enumValueSet, async () => ({
             prefix: await this.visitSpace(enumValueSet.prefix, p),
             markers: await this.visitMarkers(enumValueSet.markers, p),
             enums: await (0, util_1.mapAsync)(enumValueSet.enums, e => this.visitRightPadded(e, p))
-        };
+        }));
         return (0, util_1.updateIfChanged)(enumValueSet, updates);
     }
     async visitErroneous(erroneous, p) {
@@ -426,13 +441,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         fieldAccess = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(fieldAccess, async () => ({
             prefix: await this.visitSpace(fieldAccess.prefix, p),
             markers: await this.visitMarkers(fieldAccess.markers, p),
             target: await this.visitDefined(fieldAccess.target, p),
             name: await this.visitLeftPadded(fieldAccess.name, p),
             type: await this.visitType(fieldAccess.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(fieldAccess, updates);
     }
     async visitForEachLoop(forLoop, p) {
@@ -441,12 +456,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         forLoop = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(forLoop, async () => ({
             prefix: await this.visitSpace(forLoop.prefix, p),
             markers: await this.visitMarkers(forLoop.markers, p),
             control: await this.visitDefined(forLoop.control, p),
             body: await this.visitRightPadded(forLoop.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(forLoop, updates);
     }
     async visitForEachLoopControl(control, p) {
@@ -464,12 +479,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         forLoop = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(forLoop, async () => ({
             prefix: await this.visitSpace(forLoop.prefix, p),
             markers: await this.visitMarkers(forLoop.markers, p),
             control: await this.visitDefined(forLoop.control, p),
             body: await this.visitRightPadded(forLoop.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(forLoop, updates);
     }
     async visitForLoopControl(control, p) {
@@ -503,16 +518,18 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         iff = statement;
-        const updates = {
-            prefix: await this.visitSpace(iff.prefix, p),
-            markers: await this.visitMarkers(iff.markers, p),
-            ifCondition: await this.visitDefined(iff.ifCondition, p),
-            thenPart: await this.visitRightPadded(iff.thenPart, p)
-        };
-        if (iff.elsePart) {
-            updates.elsePart = await this.visitDefined(iff.elsePart, p);
-        }
-        return (0, util_1.updateIfChanged)(iff, updates);
+        return this.visitChildrenOf(iff, async () => {
+            const updates = {
+                prefix: await this.visitSpace(iff.prefix, p),
+                markers: await this.visitMarkers(iff.markers, p),
+                ifCondition: await this.visitDefined(iff.ifCondition, p),
+                thenPart: await this.visitRightPadded(iff.thenPart, p)
+            };
+            if (iff.elsePart) {
+                updates.elsePart = await this.visitDefined(iff.elsePart, p);
+            }
+            return (0, util_1.updateIfChanged)(iff, updates);
+        });
     }
     async visitElse(anElse, p) {
         const updates = {
@@ -538,20 +555,22 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         instanceOf = expression;
-        const updates = {
-            prefix: await this.visitSpace(instanceOf.prefix, p),
-            markers: await this.visitMarkers(instanceOf.markers, p),
-            expression: await this.visitRightPadded(instanceOf.expression, p),
-            class: await this.visitDefined(instanceOf.class, p),
-            type: await this.visitType(instanceOf.type, p)
-        };
-        if (instanceOf.pattern) {
-            updates.pattern = await this.visitDefined(instanceOf.pattern, p);
-        }
-        if (instanceOf.modifier) {
-            updates.modifier = await this.visitDefined(instanceOf.modifier, p);
-        }
-        return (0, util_1.updateIfChanged)(instanceOf, updates);
+        return this.visitChildrenOf(instanceOf, async () => {
+            const updates = {
+                prefix: await this.visitSpace(instanceOf.prefix, p),
+                markers: await this.visitMarkers(instanceOf.markers, p),
+                expression: await this.visitRightPadded(instanceOf.expression, p),
+                class: await this.visitDefined(instanceOf.class, p),
+                type: await this.visitType(instanceOf.type, p)
+            };
+            if (instanceOf.pattern) {
+                updates.pattern = await this.visitDefined(instanceOf.pattern, p);
+            }
+            if (instanceOf.modifier) {
+                updates.modifier = await this.visitDefined(instanceOf.modifier, p);
+            }
+            return (0, util_1.updateIfChanged)(instanceOf, updates);
+        });
     }
     async visitIntersectionType(intersectionType, p) {
         const expression = await this.visitExpression(intersectionType, p);
@@ -559,11 +578,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         intersectionType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(intersectionType, async () => ({
             prefix: await this.visitSpace(intersectionType.prefix, p),
             markers: await this.visitMarkers(intersectionType.markers, p),
             bounds: await this.visitContainer(intersectionType.bounds, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(intersectionType, updates);
     }
     async visitLabel(label, p) {
@@ -572,12 +591,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         label = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(label, async () => ({
             prefix: await this.visitSpace(label.prefix, p),
             markers: await this.visitMarkers(label.markers, p),
             label: await this.visitRightPadded(label.label, p),
             statement: await this.visitDefined(label.statement, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(label, updates);
     }
     async visitLambda(lambda, p) {
@@ -591,14 +610,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         lambda = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(lambda, async () => ({
             prefix: await this.visitSpace(lambda.prefix, p),
             markers: await this.visitMarkers(lambda.markers, p),
             parameters: await this.visitDefined(lambda.parameters, p),
             arrow: await this.visitSpace(lambda.arrow, p),
             body: await this.visitDefined(lambda.body, p),
             type: await this.visitType(lambda.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(lambda, updates);
     }
     async visitLambdaParameters(params, p) {
@@ -628,7 +647,7 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         memberRef = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(memberRef, async () => ({
             prefix: await this.visitSpace(memberRef.prefix, p),
             markers: await this.visitMarkers(memberRef.markers, p),
             containing: await this.visitRightPadded(memberRef.containing, p),
@@ -637,37 +656,39 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             type: await this.visitType(memberRef.type, p),
             methodType: await this.visitType(memberRef.methodType, p),
             variableType: await this.visitType(memberRef.variableType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(memberRef, updates);
     }
     async visitMethodDeclaration(method, p) {
-        var _a;
         const statement = await this.visitStatement(method, p);
         if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.MethodDeclaration) {
             return statement;
         }
         method = statement;
-        const updates = {
-            prefix: await this.visitSpace(method.prefix, p),
-            markers: await this.visitMarkers(method.markers, p),
-            leadingAnnotations: await (0, util_1.mapAsync)(method.leadingAnnotations, a => this.visitDefined(a, p)),
-            modifiers: await (0, util_1.mapAsync)(method.modifiers, m => this.visitDefined(m, p)),
-            nameAnnotations: await (0, util_1.mapAsync)(method.nameAnnotations, a => this.visitDefined(a, p)),
-            name: await this.visitDefined(method.name, p),
-            parameters: await this.visitContainer(method.parameters, p),
-            dimensionsAfterName: await (0, util_1.mapAsync)((_a = method.dimensionsAfterName) !== null && _a !== void 0 ? _a : [], dim => this.visitLeftPadded(dim, p)),
-            throws: method.throws && await this.visitContainer(method.throws, p),
-            body: method.body && await this.visitDefined(method.body, p),
-            defaultValue: await this.visitOptionalLeftPadded(method.defaultValue, p),
-            methodType: await this.visitType(method.methodType, p)
-        };
-        if (method.typeParameters) {
-            updates.typeParameters = await this.visitDefined(method.typeParameters, p);
-        }
-        if (method.returnTypeExpression) {
-            updates.returnTypeExpression = await this.visitDefined(method.returnTypeExpression, p);
-        }
-        return (0, util_1.updateIfChanged)(method, updates);
+        return this.visitChildrenOf(method, async () => {
+            var _a;
+            const updates = {
+                prefix: await this.visitSpace(method.prefix, p),
+                markers: await this.visitMarkers(method.markers, p),
+                leadingAnnotations: await (0, util_1.mapAsync)(method.leadingAnnotations, a => this.visitDefined(a, p)),
+                modifiers: await (0, util_1.mapAsync)(method.modifiers, m => this.visitDefined(m, p)),
+                nameAnnotations: await (0, util_1.mapAsync)(method.nameAnnotations, a => this.visitDefined(a, p)),
+                name: await this.visitDefined(method.name, p),
+                parameters: await this.visitContainer(method.parameters, p),
+                dimensionsAfterName: await (0, util_1.mapAsync)((_a = method.dimensionsAfterName) !== null && _a !== void 0 ? _a : [], dim => this.visitLeftPadded(dim, p)),
+                throws: method.throws && await this.visitContainer(method.throws, p),
+                body: method.body && await this.visitDefined(method.body, p),
+                defaultValue: await this.visitOptionalLeftPadded(method.defaultValue, p),
+                methodType: await this.visitType(method.methodType, p)
+            };
+            if (method.typeParameters) {
+                updates.typeParameters = await this.visitDefined(method.typeParameters, p);
+            }
+            if (method.returnTypeExpression) {
+                updates.returnTypeExpression = await this.visitDefined(method.returnTypeExpression, p);
+            }
+            return (0, util_1.updateIfChanged)(method, updates);
+        });
     }
     async visitMethodInvocation(method, p) {
         const expression = await this.visitExpression(method, p);
@@ -680,7 +701,7 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         method = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(method, async () => ({
             prefix: await this.visitSpace(method.prefix, p),
             markers: await this.visitMarkers(method.markers, p),
             select: await this.visitOptionalRightPadded(method.select, p),
@@ -688,7 +709,7 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             name: await this.visitDefined(method.name, p),
             arguments: await this.visitContainer(method.arguments, p),
             methodType: await this.visitType(method.methodType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(method, updates);
     }
     async visitModifier(modifier, p) {
@@ -713,17 +734,19 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         newArray = expression;
-        const updates = {
-            prefix: await this.visitSpace(newArray.prefix, p),
-            markers: await this.visitMarkers(newArray.markers, p),
-            dimensions: await (0, util_1.mapAsync)(newArray.dimensions, dim => this.visitDefined(dim, p)),
-            initializer: await this.visitOptionalContainer(newArray.initializer, p),
-            type: await this.visitType(newArray.type, p)
-        };
-        if (newArray.typeExpression) {
-            updates.typeExpression = await this.visitDefined(newArray.typeExpression, p);
-        }
-        return (0, util_1.updateIfChanged)(newArray, updates);
+        return this.visitChildrenOf(newArray, async () => {
+            const updates = {
+                prefix: await this.visitSpace(newArray.prefix, p),
+                markers: await this.visitMarkers(newArray.markers, p),
+                dimensions: await (0, util_1.mapAsync)(newArray.dimensions, dim => this.visitDefined(dim, p)),
+                initializer: await this.visitOptionalContainer(newArray.initializer, p),
+                type: await this.visitType(newArray.type, p)
+            };
+            if (newArray.typeExpression) {
+                updates.typeExpression = await this.visitDefined(newArray.typeExpression, p);
+            }
+            return (0, util_1.updateIfChanged)(newArray, updates);
+        });
     }
     async visitNewClass(newClass, p) {
         const expression = await this.visitExpression(newClass, p);
@@ -736,23 +759,25 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         newClass = statement;
-        const updates = {
-            prefix: await this.visitSpace(newClass.prefix, p),
-            markers: await this.visitMarkers(newClass.markers, p),
-            new: await this.visitSpace(newClass.new, p),
-            arguments: await this.visitContainer(newClass.arguments, p),
-            constructorType: await this.visitType(newClass.constructorType, p)
-        };
-        if (newClass.enclosing) {
-            updates.enclosing = await this.visitRightPadded(newClass.enclosing, p);
-        }
-        if (newClass.class) {
-            updates.class = await this.visitDefined(newClass.class, p);
-        }
-        if (newClass.body) {
-            updates.body = await this.visitDefined(newClass.body, p);
-        }
-        return (0, util_1.updateIfChanged)(newClass, updates);
+        return this.visitChildrenOf(newClass, async () => {
+            const updates = {
+                prefix: await this.visitSpace(newClass.prefix, p),
+                markers: await this.visitMarkers(newClass.markers, p),
+                new: await this.visitSpace(newClass.new, p),
+                arguments: await this.visitContainer(newClass.arguments, p),
+                constructorType: await this.visitType(newClass.constructorType, p)
+            };
+            if (newClass.enclosing) {
+                updates.enclosing = await this.visitRightPadded(newClass.enclosing, p);
+            }
+            if (newClass.class) {
+                updates.class = await this.visitDefined(newClass.class, p);
+            }
+            if (newClass.body) {
+                updates.body = await this.visitDefined(newClass.body, p);
+            }
+            return (0, util_1.updateIfChanged)(newClass, updates);
+        });
     }
     async visitNullableType(nullableType, p) {
         const expression = await this.visitExpression(nullableType, p);
@@ -760,12 +785,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         nullableType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(nullableType, async () => ({
             prefix: await this.visitSpace(nullableType.prefix, p),
             markers: await this.visitMarkers(nullableType.markers, p),
             annotations: await (0, util_1.mapAsync)(nullableType.annotations, a => this.visitDefined(a, p)),
             typeTree: await this.visitRightPadded(nullableType.typeTree, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(nullableType, updates);
     }
     async visitPackage(aPackage, p) {
@@ -785,13 +810,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         parameterizedType = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(parameterizedType, async () => ({
             prefix: await this.visitSpace(parameterizedType.prefix, p),
             markers: await this.visitMarkers(parameterizedType.markers, p),
             class: await this.visitTypeName(parameterizedType.class, p),
             typeParameters: await this.visitOptionalContainer(parameterizedType.typeParameters, p),
             type: await this.visitType(parameterizedType.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(parameterizedType, updates);
     }
     async visitParentheses(parentheses, p) {
@@ -800,11 +825,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         parentheses = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(parentheses, async () => ({
             prefix: await this.visitSpace(parentheses.prefix, p),
             markers: await this.visitMarkers(parentheses.markers, p),
             tree: await this.visitRightPadded(parentheses.tree, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(parentheses, updates);
     }
     async visitParenthesizedTypeTree(parTypeTree, p) {
@@ -813,12 +838,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         parTypeTree = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(parTypeTree, async () => ({
             prefix: await this.visitSpace(parTypeTree.prefix, p),
             markers: await this.visitMarkers(parTypeTree.markers, p),
             annotations: await (0, util_1.mapAsync)(parTypeTree.annotations, a => this.visitDefined(a, p)),
             parenthesizedType: await this.visitDefined(parTypeTree.parenthesizedType, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(parTypeTree, updates);
     }
     async visitPrimitive(primitive, p) {
@@ -840,14 +865,16 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         ret = statement;
-        const updates = {
-            prefix: await this.visitSpace(ret.prefix, p),
-            markers: await this.visitMarkers(ret.markers, p)
-        };
-        if (ret.expression) {
-            updates.expression = await this.visitDefined(ret.expression, p);
-        }
-        return (0, util_1.updateIfChanged)(ret, updates);
+        return this.visitChildrenOf(ret, async () => {
+            const updates = {
+                prefix: await this.visitSpace(ret.prefix, p),
+                markers: await this.visitMarkers(ret.markers, p)
+            };
+            if (ret.expression) {
+                updates.expression = await this.visitDefined(ret.expression, p);
+            }
+            return (0, util_1.updateIfChanged)(ret, updates);
+        });
     }
     async visitSwitch(aSwitch, p) {
         const statement = await this.visitStatement(aSwitch, p);
@@ -855,12 +882,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         aSwitch = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(aSwitch, async () => ({
             prefix: await this.visitSpace(aSwitch.prefix, p),
             markers: await this.visitMarkers(aSwitch.markers, p),
             selector: await this.visitDefined(aSwitch.selector, p),
             cases: await this.visitDefined(aSwitch.cases, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(aSwitch, updates);
     }
     async visitSwitchExpression(switchExpr, p) {
@@ -869,13 +896,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         switchExpr = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(switchExpr, async () => ({
             prefix: await this.visitSpace(switchExpr.prefix, p),
             markers: await this.visitMarkers(switchExpr.markers, p),
             selector: await this.visitDefined(switchExpr.selector, p),
             cases: await this.visitDefined(switchExpr.cases, p),
             type: await this.visitType(switchExpr.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(switchExpr, updates);
     }
     async visitSynchronized(sync, p) {
@@ -884,12 +911,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         sync = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(sync, async () => ({
             prefix: await this.visitSpace(sync.prefix, p),
             markers: await this.visitMarkers(sync.markers, p),
             lock: await this.visitDefined(sync.lock, p),
             body: await this.visitDefined(sync.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(sync, updates);
     }
     async visitTernary(ternary, p) {
@@ -903,14 +930,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         ternary = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(ternary, async () => ({
             prefix: await this.visitSpace(ternary.prefix, p),
             markers: await this.visitMarkers(ternary.markers, p),
             condition: await this.visitDefined(ternary.condition, p),
             truePart: await this.visitLeftPadded(ternary.truePart, p),
             falsePart: await this.visitLeftPadded(ternary.falsePart, p),
             type: await this.visitType(ternary.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(ternary, updates);
     }
     async visitThrow(thrown, p) {
@@ -919,11 +946,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         thrown = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(thrown, async () => ({
             prefix: await this.visitSpace(thrown.prefix, p),
             markers: await this.visitMarkers(thrown.markers, p),
             exception: await this.visitDefined(thrown.exception, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(thrown, updates);
     }
     async visitTry(tryable, p) {
@@ -932,14 +959,14 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         tryable = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(tryable, async () => ({
             prefix: await this.visitSpace(tryable.prefix, p),
             markers: await this.visitMarkers(tryable.markers, p),
             resources: await this.visitOptionalContainer(tryable.resources, p),
             body: await this.visitDefined(tryable.body, p),
             catches: await (0, util_1.mapAsync)(tryable.catches, c => this.visitDefined(c, p)),
             finally: await this.visitOptionalLeftPadded(tryable.finally, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(tryable, updates);
     }
     async visitTryResource(resource, p) {
@@ -965,12 +992,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         typeCast = expression;
-        const updates = {
+        const updates = await this.visitChildrenOf(typeCast, async () => ({
             prefix: await this.visitSpace(typeCast.prefix, p),
             markers: await this.visitMarkers(typeCast.markers, p),
             class: await this.visitDefined(typeCast.class, p),
             expression: await this.visitDefined(typeCast.expression, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(typeCast, updates);
     }
     async visitTypeParameter(typeParam, p) {
@@ -1004,13 +1031,13 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         unary = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(unary, async () => ({
             prefix: await this.visitSpace(unary.prefix, p),
             markers: await this.visitMarkers(unary.markers, p),
             operator: await this.visitLeftPadded(unary.operator, p),
             expression: await this.visitDefined(unary.expression, p),
             type: await this.visitType(unary.type, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(unary, updates);
     }
     async visitUnknown(unknown, p) {
@@ -1024,11 +1051,11 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         unknown = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(unknown, async () => ({
             prefix: await this.visitSpace(unknown.prefix, p),
             markers: await this.visitMarkers(unknown.markers, p),
             source: await this.visitDefined(unknown.source, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(unknown, updates);
     }
     async visitUnknownSource(source, p) {
@@ -1044,20 +1071,22 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         varDecls = statement;
-        const updates = {
-            prefix: await this.visitSpace(varDecls.prefix, p),
-            markers: await this.visitMarkers(varDecls.markers, p),
-            leadingAnnotations: await (0, util_1.mapAsync)(varDecls.leadingAnnotations, a => this.visitDefined(a, p)),
-            modifiers: await (0, util_1.mapAsync)(varDecls.modifiers, m => this.visitDefined(m, p)),
-            variables: await (0, util_1.mapAsync)(varDecls.variables, v => this.visitRightPadded(v, p))
-        };
-        if (varDecls.typeExpression) {
-            updates.typeExpression = await this.visitDefined(varDecls.typeExpression, p);
-        }
-        if (varDecls.varargs) {
-            updates.varargs = await this.visitSpace(varDecls.varargs, p);
-        }
-        return (0, util_1.updateIfChanged)(varDecls, updates);
+        return this.visitChildrenOf(varDecls, async () => {
+            const updates = {
+                prefix: await this.visitSpace(varDecls.prefix, p),
+                markers: await this.visitMarkers(varDecls.markers, p),
+                leadingAnnotations: await (0, util_1.mapAsync)(varDecls.leadingAnnotations, a => this.visitDefined(a, p)),
+                modifiers: await (0, util_1.mapAsync)(varDecls.modifiers, m => this.visitDefined(m, p)),
+                variables: await (0, util_1.mapAsync)(varDecls.variables, v => this.visitRightPadded(v, p))
+            };
+            if (varDecls.typeExpression) {
+                updates.typeExpression = await this.visitDefined(varDecls.typeExpression, p);
+            }
+            if (varDecls.varargs) {
+                updates.varargs = await this.visitSpace(varDecls.varargs, p);
+            }
+            return (0, util_1.updateIfChanged)(varDecls, updates);
+        });
     }
     async visitVariable(variable, p) {
         const updates = {
@@ -1076,12 +1105,12 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         whileLoop = statement;
-        const updates = {
+        const updates = await this.visitChildrenOf(whileLoop, async () => ({
             prefix: await this.visitSpace(whileLoop.prefix, p),
             markers: await this.visitMarkers(whileLoop.markers, p),
             condition: await this.visitDefined(whileLoop.condition, p),
             body: await this.visitRightPadded(whileLoop.body, p)
-        };
+        }));
         return (0, util_1.updateIfChanged)(whileLoop, updates);
     }
     async visitWildcard(wildcard, p) {
@@ -1090,15 +1119,17 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return expression;
         }
         wildcard = expression;
-        const updates = {
-            prefix: await this.visitSpace(wildcard.prefix, p),
-            markers: await this.visitMarkers(wildcard.markers, p),
-            bound: await this.visitOptionalLeftPadded(wildcard.bound, p)
-        };
-        if (wildcard.boundedType) {
-            updates.boundedType = await this.visitTypeName(wildcard.boundedType, p);
-        }
-        return (0, util_1.updateIfChanged)(wildcard, updates);
+        return this.visitChildrenOf(wildcard, async () => {
+            const updates = {
+                prefix: await this.visitSpace(wildcard.prefix, p),
+                markers: await this.visitMarkers(wildcard.markers, p),
+                bound: await this.visitOptionalLeftPadded(wildcard.bound, p)
+            };
+            if (wildcard.boundedType) {
+                updates.boundedType = await this.visitTypeName(wildcard.boundedType, p);
+            }
+            return (0, util_1.updateIfChanged)(wildcard, updates);
+        });
     }
     async visitYield(aYield, p) {
         const statement = await this.visitStatement(aYield, p);
@@ -1106,15 +1137,17 @@ class JavaVisitor extends visitor_1.TreeVisitor {
             return statement;
         }
         aYield = statement;
-        const updates = {
-            prefix: await this.visitSpace(aYield.prefix, p),
-            markers: await this.visitMarkers(aYield.markers, p)
-        };
-        // a bare `yield` has no value
-        if (aYield.value) {
-            updates.value = await this.visitDefined(aYield.value, p);
-        }
-        return (0, util_1.updateIfChanged)(aYield, updates);
+        return this.visitChildrenOf(aYield, async () => {
+            const updates = {
+                prefix: await this.visitSpace(aYield.prefix, p),
+                markers: await this.visitMarkers(aYield.markers, p)
+            };
+            // a bare `yield` has no value
+            if (aYield.value) {
+                updates.value = await this.visitDefined(aYield.value, p);
+            }
+            return (0, util_1.updateIfChanged)(aYield, updates);
+        });
     }
     async visitOptionalRightPadded(right, p) {
         return right ? this.visitRightPadded(right, p) : undefined;