@openrewrite/rewrite 8.72.2 → 8.72.3

package/dist/java/visitor.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaVisitor = void 0;
 exports.registerJavaExtensionKinds = registerJavaExtensionKinds;
@@ -50,1256 +41,1088 @@ function isJava(tree) {
 }
 class JavaVisitor extends visitor_1.TreeVisitor {
     // protected javadocVisitor: any | null = null;
-    isAcceptable(sourceFile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return isJava(sourceFile);
-        });
+    async isAcceptable(sourceFile) {
+        return isJava(sourceFile);
     }
     // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
-    visitExpression(expression, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return expression;
-        });
+    async visitExpression(expression, p) {
+        return expression;
     }
     // noinspection JSUnusedGlobalSymbols,JSUnusedLocalSymbols
-    visitStatement(statement, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return statement;
-        });
+    async visitStatement(statement, p) {
+        return statement;
     }
     // noinspection JSUnusedLocalSymbols
-    visitSpace(space, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return space;
-        });
+    async visitSpace(space, p) {
+        return space;
     }
     // noinspection JSUnusedLocalSymbols
-    visitType(javaType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return javaType;
-        });
+    async visitType(javaType, p) {
+        return javaType;
     }
     // noinspection JSUnusedLocalSymbols
-    visitTypeName(nameTree, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return nameTree;
-        });
-    }
-    visitAnnotatedType(annotatedType, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield 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 = {
-                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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(annotation, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Annotation) {
-                return expression;
-            }
-            annotation = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(arrayAccess, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.ArrayAccess) {
-                return expression;
-            }
-            arrayAccess = expression;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(arrayType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.ArrayType) {
-                return expression;
-            }
-            arrayType = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(anAssert, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Assert) {
-                return statement;
-            }
-            anAssert = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(assignment, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Assignment) {
-                return expression;
-            }
-            assignment = expression;
-            const statement = yield this.visitStatement(assignment, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Assignment) {
-                return statement;
-            }
-            assignment = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(assignOp, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.AssignmentOperation) {
-                return expression;
-            }
-            assignOp = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(binary, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Binary) {
-                return expression;
-            }
-            binary = expression;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(breakStatement, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Break) {
-                return statement;
-            }
-            breakStatement = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(aCase, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Case) {
-                return statement;
-            }
-            aCase = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(classDecl, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.ClassDeclaration) {
-                return statement;
-            }
-            classDecl = statement;
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(continueStatement, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Continue) {
-                return statement;
-            }
-            continueStatement = statement;
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(doWhileLoop, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.DoWhileLoop) {
-                return statement;
-            }
-            doWhileLoop = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(empty, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Empty) {
-                return expression;
-            }
-            empty = expression;
-            const statement = yield this.visitStatement(empty, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Empty) {
-                return statement;
-            }
-            empty = statement;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(enumValueSet, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.EnumValueSet) {
-                return statement;
-            }
-            enumValueSet = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(erroneous, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Erroneous) {
-                return expression;
-            }
-            erroneous = expression;
-            const statement = yield this.visitStatement(erroneous, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Erroneous) {
-                return statement;
-            }
-            erroneous = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(fieldAccess, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.FieldAccess) {
-                return expression;
-            }
-            fieldAccess = expression;
-            const statement = yield this.visitStatement(fieldAccess, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.FieldAccess) {
-                return statement;
-            }
-            fieldAccess = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(forLoop, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.ForEachLoop) {
-                return statement;
-            }
-            forLoop = statement;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(forLoop, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.ForLoop) {
-                return statement;
-            }
-            forLoop = statement;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(ident, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Identifier) {
-                return expression;
-            }
-            ident = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(iff, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.If) {
-                return statement;
-            }
-            iff = statement;
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(instanceOf, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.InstanceOf) {
-                return expression;
-            }
-            instanceOf = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(intersectionType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.IntersectionType) {
-                return expression;
-            }
-            intersectionType = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(label, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Label) {
-                return statement;
-            }
-            label = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(lambda, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Lambda) {
-                return expression;
-            }
-            lambda = expression;
-            const statement = yield this.visitStatement(lambda, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Lambda) {
-                return statement;
-            }
-            lambda = statement;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(literal, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Literal) {
-                return expression;
-            }
-            literal = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(memberRef, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.MemberReference) {
-                return expression;
-            }
-            memberRef = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield 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: 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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(method, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.MethodInvocation) {
-                return expression;
-            }
-            method = expression;
-            const statement = yield this.visitStatement(method, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.MethodInvocation) {
-                return statement;
-            }
-            method = statement;
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(newArray, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.NewArray) {
-                return expression;
-            }
-            newArray = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(newClass, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.NewClass) {
-                return expression;
-            }
-            newClass = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(nullableType, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.NullableType) {
-                return expression;
-            }
-            nullableType = expression;
-            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* () {
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(parTypeTree, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.ParenthesizedTypeTree) {
-                return expression;
-            }
-            parTypeTree = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(primitive, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Primitive) {
-                return expression;
-            }
-            primitive = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(ret, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Return) {
-                return statement;
-            }
-            ret = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(aSwitch, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Switch) {
-                return statement;
-            }
-            aSwitch = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(switchExpr, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.SwitchExpression) {
-                return expression;
-            }
-            switchExpr = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(sync, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Synchronized) {
-                return statement;
-            }
-            sync = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(ternary, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Ternary) {
-                return expression;
-            }
-            ternary = expression;
-            const statement = yield this.visitStatement(ternary, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Ternary) {
-                return statement;
-            }
-            ternary = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(thrown, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Throw) {
-                return statement;
-            }
-            thrown = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(tryable, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Try) {
-                return statement;
-            }
-            tryable = statement;
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(typeCast, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.TypeCast) {
-                return expression;
-            }
-            typeCast = expression;
-            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* () {
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(unary, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Unary) {
-                return expression;
-            }
-            unary = expression;
-            const statement = yield this.visitStatement(unary, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Unary) {
-                return statement;
-            }
-            unary = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(unknown, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Unknown) {
-                return expression;
-            }
-            unknown = expression;
-            const statement = yield this.visitStatement(unknown, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Unknown) {
-                return statement;
-            }
-            unknown = statement;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(varDecls, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.VariableDeclarations) {
-                return statement;
-            }
-            varDecls = statement;
-            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* () {
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(whileLoop, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.WhileLoop) {
-                return statement;
-            }
-            whileLoop = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const expression = yield this.visitExpression(wildcard, p);
-            if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Wildcard) {
-                return expression;
-            }
-            wildcard = expression;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const statement = yield this.visitStatement(aYield, p);
-            if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Yield) {
-                return statement;
-            }
-            aYield = statement;
-            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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return right ? this.visitRightPadded(right, p) : undefined;
-        });
-    }
-    visitRightPadded(right, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cursor = new tree_1.Cursor(right, this.cursor);
-            const element = (0, tree_1.isTree)(right.element) ? yield this.visitDefined(right.element, p) : right.element;
-            const after = yield this.visitSpace(right.after, p);
-            const markers = yield this.visitMarkers(right.markers, p);
-            this.cursor = this.cursor.parent;
-            if (element === undefined) {
-                return undefined;
-            }
-            return (0, util_1.updateIfChanged)(right, { element, after, markers });
-        });
-    }
-    visitOptionalLeftPadded(left, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return left ? this.visitLeftPadded(left, p) : undefined;
-        });
-    }
-    visitLeftPadded(left, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cursor = new tree_1.Cursor(left, this.cursor);
-            const before = yield this.visitSpace(left.before, p);
-            let element = left.element;
-            if ((0, tree_1.isTree)(left.element)) {
-                element = (yield this.visitDefined(left.element, p));
-            }
-            else if ((0, tree_2.isSpace)(left.element)) {
-                element = (yield this.visitSpace(left.element, p));
-            }
-            const markers = yield this.visitMarkers(left.markers, p);
-            this.cursor = this.cursor.parent;
-            if (element === undefined) {
-                return undefined;
-            }
-            return (0, util_1.updateIfChanged)(left, { before, element, markers });
-        });
-    }
-    visitOptionalContainer(container, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return container ? this.visitContainer(container, p) : undefined;
-        });
-    }
-    visitContainer(container, p) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cursor = new tree_1.Cursor(container, this.cursor);
-            const before = yield this.visitSpace(container.before, p);
-            const elements = yield (0, util_1.mapAsync)(container.elements, e => this.visitRightPadded(e, p));
-            const markers = yield this.visitMarkers(container.markers, p);
-            this.cursor = this.cursor.parent;
-            return (0, util_1.updateIfChanged)(container, { before, elements, markers });
-        });
-    }
-    produceJava(before, p, recipe) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [draft, finishDraft] = (0, mutative_1.create)(before);
-            draft.prefix = yield this.visitSpace(before.prefix, p);
-            draft.markers = yield this.visitMarkers(before.markers, p);
-            if (recipe) {
-                yield recipe(draft);
-            }
-            return finishDraft();
-        });
+    async visitTypeName(nameTree, p) {
+        return nameTree;
+    }
+    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 = {
+            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) {
+        const expression = await this.visitExpression(annotation, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Annotation) {
+            return expression;
+        }
+        annotation = expression;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(arrayAccess, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.ArrayAccess) {
+            return expression;
+        }
+        arrayAccess = expression;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(arrayDimension.prefix, p),
+            markers: await this.visitMarkers(arrayDimension.markers, p),
+            index: await this.visitRightPadded(arrayDimension.index, p)
+        };
+        return (0, util_1.updateIfChanged)(arrayDimension, updates);
+    }
+    async visitArrayType(arrayType, p) {
+        const expression = await this.visitExpression(arrayType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.ArrayType) {
+            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);
+    }
+    async visitAssert(anAssert, p) {
+        const statement = await this.visitStatement(anAssert, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Assert) {
+            return statement;
+        }
+        anAssert = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(assignment, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Assignment) {
+            return expression;
+        }
+        assignment = expression;
+        const statement = await this.visitStatement(assignment, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Assignment) {
+            return statement;
+        }
+        assignment = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(assignOp, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.AssignmentOperation) {
+            return expression;
+        }
+        assignOp = expression;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(binary, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Binary) {
+            return expression;
+        }
+        binary = expression;
+        const updates = {
+            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)
+        };
+        return (0, util_1.updateIfChanged)(binary, updates);
+    }
+    async visitBlock(block, p) {
+        const updates = {
+            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) {
+        const statement = await this.visitStatement(breakStatement, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Break) {
+            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);
+    }
+    async visitCase(aCase, p) {
+        const statement = await this.visitStatement(aCase, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Case) {
+            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);
+    }
+    async visitClassDeclaration(classDecl, p) {
+        const statement = await this.visitStatement(classDecl, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.ClassDeclaration) {
+            return statement;
+        }
+        classDecl = statement;
+        const updates = {
+            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)),
+            modifiers: await (0, util_1.mapAsync)(classDecl.modifiers, m => this.visitDefined(m, p)),
+            classKind: await this.visitDefined(classDecl.classKind, p),
+            name: await this.visitDefined(classDecl.name, p),
+            typeParameters: await this.visitOptionalContainer(classDecl.typeParameters, p),
+            primaryConstructor: await this.visitOptionalContainer(classDecl.primaryConstructor, p),
+            extends: await this.visitOptionalLeftPadded(classDecl.extends, p),
+            implements: await this.visitOptionalContainer(classDecl.implements, p),
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(kind.prefix, p),
+            markers: await this.visitMarkers(kind.markers, p),
+            annotations: await (0, util_1.mapAsync)(kind.annotations, a => this.visitDefined(a, p))
+        };
+        return (0, util_1.updateIfChanged)(kind, updates);
+    }
+    async visitCompilationUnit(cu, p) {
+        const updates = {
+            prefix: await this.visitSpace(cu.prefix, p),
+            markers: await this.visitMarkers(cu.markers, p),
+            packageDeclaration: await this.visitRightPadded(cu.packageDeclaration, p),
+            imports: await (0, util_1.mapAsync)(cu.imports, imp => this.visitRightPadded(imp, p)),
+            classes: await (0, util_1.mapAsync)(cu.classes, cls => this.visitDefined(cls, p)),
+            eof: await this.visitSpace(cu.eof, p)
+        };
+        return (0, util_1.updateIfChanged)(cu, updates);
+    }
+    async visitContinue(continueStatement, p) {
+        const statement = await this.visitStatement(continueStatement, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Continue) {
+            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);
+    }
+    async visitControlParentheses(controlParens, p) {
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(pattern.prefix, p),
+            markers: await this.visitMarkers(pattern.markers, p),
+            deconstructor: await this.visitDefined(pattern.deconstructor, p),
+            nested: await this.visitContainer(pattern.nested, p),
+            type: await this.visitType(pattern.type, p)
+        };
+        return (0, util_1.updateIfChanged)(pattern, updates);
+    }
+    async visitDoWhileLoop(doWhileLoop, p) {
+        const statement = await this.visitStatement(doWhileLoop, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.DoWhileLoop) {
+            return statement;
+        }
+        doWhileLoop = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(empty, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Empty) {
+            return expression;
+        }
+        empty = expression;
+        const statement = await this.visitStatement(empty, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Empty) {
+            return statement;
+        }
+        empty = statement;
+        const updates = {
+            prefix: await this.visitSpace(empty.prefix, p),
+            markers: await this.visitMarkers(empty.markers, p)
+        };
+        return (0, util_1.updateIfChanged)(empty, updates);
+    }
+    async visitEnumValue(enumValue, p) {
+        const updates = {
+            prefix: await this.visitSpace(enumValue.prefix, p),
+            markers: await this.visitMarkers(enumValue.markers, p),
+            annotations: await (0, util_1.mapAsync)(enumValue.annotations, a => this.visitDefined(a, p)),
+            name: await this.visitDefined(enumValue.name, p)
+        };
+        if (enumValue.initializer) {
+            updates.initializer = await this.visitDefined(enumValue.initializer, p);
+        }
+        return (0, util_1.updateIfChanged)(enumValue, updates);
+    }
+    async visitEnumValueSet(enumValueSet, p) {
+        const statement = await this.visitStatement(enumValueSet, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.EnumValueSet) {
+            return statement;
+        }
+        enumValueSet = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(erroneous, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Erroneous) {
+            return expression;
+        }
+        erroneous = expression;
+        const statement = await this.visitStatement(erroneous, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Erroneous) {
+            return statement;
+        }
+        erroneous = statement;
+        const updates = {
+            prefix: await this.visitSpace(erroneous.prefix, p),
+            markers: await this.visitMarkers(erroneous.markers, p)
+        };
+        return (0, util_1.updateIfChanged)(erroneous, updates);
+    }
+    async visitFieldAccess(fieldAccess, p) {
+        const expression = await this.visitExpression(fieldAccess, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.FieldAccess) {
+            return expression;
+        }
+        fieldAccess = expression;
+        const statement = await this.visitStatement(fieldAccess, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.FieldAccess) {
+            return statement;
+        }
+        fieldAccess = statement;
+        const updates = {
+            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) {
+        const statement = await this.visitStatement(forLoop, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.ForEachLoop) {
+            return statement;
+        }
+        forLoop = statement;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(control.prefix, p),
+            markers: await this.visitMarkers(control.markers, p),
+            variable: await this.visitRightPadded(control.variable, p),
+            iterable: await this.visitRightPadded(control.iterable, p)
+        };
+        return (0, util_1.updateIfChanged)(control, updates);
+    }
+    async visitForLoop(forLoop, p) {
+        const statement = await this.visitStatement(forLoop, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.ForLoop) {
+            return statement;
+        }
+        forLoop = statement;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(control.prefix, p),
+            markers: await this.visitMarkers(control.markers, p),
+            init: await (0, util_1.mapAsync)(control.init, i => this.visitRightPadded(i, p)),
+            condition: await this.visitOptionalRightPadded(control.condition, p),
+            update: await (0, util_1.mapAsync)(control.update, u => this.visitRightPadded(u, p))
+        };
+        return (0, util_1.updateIfChanged)(control, updates);
+    }
+    async visitIdentifier(ident, p) {
+        const expression = await this.visitExpression(ident, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Identifier) {
+            return expression;
+        }
+        ident = expression;
+        const updates = {
+            prefix: await this.visitSpace(ident.prefix, p),
+            markers: await this.visitMarkers(ident.markers, p),
+            annotations: await (0, util_1.mapAsync)(ident.annotations, a => this.visitDefined(a, p)),
+            type: await this.visitType(ident.type, p),
+            fieldType: await this.visitType(ident.fieldType, p)
+        };
+        return (0, util_1.updateIfChanged)(ident, updates);
+    }
+    async visitIf(iff, p) {
+        const statement = await this.visitStatement(iff, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.If) {
+            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);
+    }
+    async visitElse(anElse, p) {
+        const updates = {
+            prefix: await this.visitSpace(anElse.prefix, p),
+            markers: await this.visitMarkers(anElse.markers, p),
+            body: await this.visitRightPadded(anElse.body, p)
+        };
+        return (0, util_1.updateIfChanged)(anElse, updates);
+    }
+    async visitImport(anImport, p) {
+        const updates = {
+            prefix: await this.visitSpace(anImport.prefix, p),
+            markers: await this.visitMarkers(anImport.markers, p),
+            static: await this.visitLeftPadded(anImport.static, p),
+            qualid: await this.visitDefined(anImport.qualid, p),
+            alias: await this.visitOptionalLeftPadded(anImport.alias, p)
+        };
+        return (0, util_1.updateIfChanged)(anImport, updates);
+    }
+    async visitInstanceOf(instanceOf, p) {
+        const expression = await this.visitExpression(instanceOf, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.InstanceOf) {
+            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);
+    }
+    async visitIntersectionType(intersectionType, p) {
+        const expression = await this.visitExpression(intersectionType, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.IntersectionType) {
+            return expression;
+        }
+        intersectionType = expression;
+        const updates = {
+            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) {
+        const statement = await this.visitStatement(label, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Label) {
+            return statement;
+        }
+        label = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(lambda, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Lambda) {
+            return expression;
+        }
+        lambda = expression;
+        const statement = await this.visitStatement(lambda, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Lambda) {
+            return statement;
+        }
+        lambda = statement;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(params.prefix, p),
+            markers: await this.visitMarkers(params.markers, p),
+            parameters: await (0, util_1.mapAsync)(params.parameters, param => this.visitRightPadded(param, p))
+        };
+        return (0, util_1.updateIfChanged)(params, updates);
+    }
+    async visitLiteral(literal, p) {
+        const expression = await this.visitExpression(literal, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Literal) {
+            return expression;
+        }
+        literal = expression;
+        const updates = {
+            prefix: await this.visitSpace(literal.prefix, p),
+            markers: await this.visitMarkers(literal.markers, p),
+            type: await this.visitType(literal.type, p)
+        };
+        return (0, util_1.updateIfChanged)(literal, updates);
+    }
+    async visitMemberReference(memberRef, p) {
+        const expression = await this.visitExpression(memberRef, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.MemberReference) {
+            return expression;
+        }
+        memberRef = expression;
+        const updates = {
+            prefix: await this.visitSpace(memberRef.prefix, p),
+            markers: await this.visitMarkers(memberRef.markers, p),
+            containing: await this.visitRightPadded(memberRef.containing, p),
+            typeParameters: await this.visitOptionalContainer(memberRef.typeParameters, p),
+            reference: await this.visitLeftPadded(memberRef.reference, p),
+            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) {
+        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),
+            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);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.MethodInvocation) {
+            return expression;
+        }
+        method = expression;
+        const statement = await this.visitStatement(method, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.MethodInvocation) {
+            return statement;
+        }
+        method = statement;
+        const updates = {
+            prefix: await this.visitSpace(method.prefix, p),
+            markers: await this.visitMarkers(method.markers, p),
+            select: await this.visitOptionalRightPadded(method.select, p),
+            typeParameters: await this.visitOptionalContainer(method.typeParameters, p),
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(modifier.prefix, p),
+            markers: await this.visitMarkers(modifier.markers, p),
+            annotations: await (0, util_1.mapAsync)(modifier.annotations, a => this.visitDefined(a, p))
+        };
+        return (0, util_1.updateIfChanged)(modifier, updates);
+    }
+    async visitMultiCatch(multiCatch, p) {
+        const updates = {
+            prefix: await this.visitSpace(multiCatch.prefix, p),
+            markers: await this.visitMarkers(multiCatch.markers, p),
+            alternatives: await (0, util_1.mapAsync)(multiCatch.alternatives, alt => this.visitRightPadded(alt, p))
+        };
+        return (0, util_1.updateIfChanged)(multiCatch, updates);
+    }
+    async visitNewArray(newArray, p) {
+        const expression = await this.visitExpression(newArray, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.NewArray) {
+            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);
+    }
+    async visitNewClass(newClass, p) {
+        const expression = await this.visitExpression(newClass, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.NewClass) {
+            return expression;
+        }
+        newClass = expression;
+        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);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.NullableType) {
+            return expression;
+        }
+        nullableType = expression;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(aPackage.prefix, p),
+            markers: await this.visitMarkers(aPackage.markers, p),
+            expression: await this.visitDefined(aPackage.expression, p)
+        };
+        if (aPackage.annotations) {
+            updates.annotations = await (0, util_1.mapAsync)(aPackage.annotations, a => this.visitDefined(a, p));
+        }
+        return (0, util_1.updateIfChanged)(aPackage, updates);
+    }
+    async visitParameterizedType(parameterizedType, p) {
+        const updates = {
+            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) {
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(parTypeTree, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.ParenthesizedTypeTree) {
+            return expression;
+        }
+        parTypeTree = expression;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(primitive, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Primitive) {
+            return expression;
+        }
+        primitive = expression;
+        const updates = {
+            prefix: await this.visitSpace(primitive.prefix, p),
+            markers: await this.visitMarkers(primitive.markers, p),
+            type: await this.visitType(primitive.type, p)
+        };
+        return (0, util_1.updateIfChanged)(primitive, updates);
+    }
+    async visitReturn(ret, p) {
+        const statement = await this.visitStatement(ret, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Return) {
+            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);
+    }
+    async visitSwitch(aSwitch, p) {
+        const statement = await this.visitStatement(aSwitch, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Switch) {
+            return statement;
+        }
+        aSwitch = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(switchExpr, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.SwitchExpression) {
+            return expression;
+        }
+        switchExpr = expression;
+        const updates = {
+            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) {
+        const statement = await this.visitStatement(sync, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Synchronized) {
+            return statement;
+        }
+        sync = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(ternary, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Ternary) {
+            return expression;
+        }
+        ternary = expression;
+        const statement = await this.visitStatement(ternary, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Ternary) {
+            return statement;
+        }
+        ternary = statement;
+        const updates = {
+            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) {
+        const statement = await this.visitStatement(thrown, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Throw) {
+            return statement;
+        }
+        thrown = statement;
+        const updates = {
+            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) {
+        const statement = await this.visitStatement(tryable, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Try) {
+            return statement;
+        }
+        tryable = statement;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(resource.prefix, p),
+            markers: await this.visitMarkers(resource.markers, p),
+            variableDeclarations: await this.visitDefined(resource.variableDeclarations, p)
+        };
+        return (0, util_1.updateIfChanged)(resource, updates);
+    }
+    async visitTryCatch(tryCatch, p) {
+        const updates = {
+            prefix: await this.visitSpace(tryCatch.prefix, p),
+            markers: await this.visitMarkers(tryCatch.markers, p),
+            parameter: await this.visitDefined(tryCatch.parameter, p),
+            body: await this.visitDefined(tryCatch.body, p)
+        };
+        return (0, util_1.updateIfChanged)(tryCatch, updates);
+    }
+    async visitTypeCast(typeCast, p) {
+        const expression = await this.visitExpression(typeCast, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.TypeCast) {
+            return expression;
+        }
+        typeCast = expression;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(typeParam.prefix, p),
+            markers: await this.visitMarkers(typeParam.markers, p),
+            annotations: await (0, util_1.mapAsync)(typeParam.annotations, a => this.visitDefined(a, p)),
+            modifiers: await (0, util_1.mapAsync)(typeParam.modifiers, m => this.visitDefined(m, p)),
+            name: await this.visitDefined(typeParam.name, p),
+            bounds: await this.visitOptionalContainer(typeParam.bounds, p)
+        };
+        return (0, util_1.updateIfChanged)(typeParam, updates);
+    }
+    async visitTypeParameters(typeParams, p) {
+        const updates = {
+            prefix: await this.visitSpace(typeParams.prefix, p),
+            markers: await this.visitMarkers(typeParams.markers, p),
+            annotations: await (0, util_1.mapAsync)(typeParams.annotations, a => this.visitDefined(a, p)),
+            typeParameters: await (0, util_1.mapAsync)(typeParams.typeParameters, tp => this.visitRightPadded(tp, p))
+        };
+        return (0, util_1.updateIfChanged)(typeParams, updates);
+    }
+    async visitUnary(unary, p) {
+        const expression = await this.visitExpression(unary, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Unary) {
+            return expression;
+        }
+        unary = expression;
+        const statement = await this.visitStatement(unary, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Unary) {
+            return statement;
+        }
+        unary = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(unknown, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Unknown) {
+            return expression;
+        }
+        unknown = expression;
+        const statement = await this.visitStatement(unknown, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Unknown) {
+            return statement;
+        }
+        unknown = statement;
+        const updates = {
+            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) {
+        const updates = {
+            prefix: await this.visitSpace(source.prefix, p),
+            markers: await this.visitMarkers(source.markers, p)
+        };
+        return (0, util_1.updateIfChanged)(source, updates);
+    }
+    async visitVariableDeclarations(varDecls, p) {
+        const statement = await this.visitStatement(varDecls, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.VariableDeclarations) {
+            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);
+    }
+    async visitVariable(variable, p) {
+        const updates = {
+            prefix: await this.visitSpace(variable.prefix, p),
+            markers: await this.visitMarkers(variable.markers, p),
+            name: await this.visitDefined(variable.name, p),
+            dimensionsAfterName: await (0, util_1.mapAsync)(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, p)),
+            initializer: await this.visitOptionalLeftPadded(variable.initializer, p),
+            variableType: await this.visitType(variable.variableType, p)
+        };
+        return (0, util_1.updateIfChanged)(variable, updates);
+    }
+    async visitWhileLoop(whileLoop, p) {
+        const statement = await this.visitStatement(whileLoop, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.WhileLoop) {
+            return statement;
+        }
+        whileLoop = statement;
+        const updates = {
+            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) {
+        const expression = await this.visitExpression(wildcard, p);
+        if (!(expression === null || expression === void 0 ? void 0 : expression.kind) || expression.kind !== tree_2.J.Kind.Wildcard) {
+            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);
+    }
+    async visitYield(aYield, p) {
+        const statement = await this.visitStatement(aYield, p);
+        if (!(statement === null || statement === void 0 ? void 0 : statement.kind) || statement.kind !== tree_2.J.Kind.Yield) {
+            return statement;
+        }
+        aYield = statement;
+        const updates = {
+            prefix: await this.visitSpace(aYield.prefix, p),
+            markers: await this.visitMarkers(aYield.markers, p),
+            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;
+    }
+    async visitRightPadded(right, p) {
+        this.cursor = new tree_1.Cursor(right, this.cursor);
+        const element = (0, tree_1.isTree)(right.element) ? await this.visitDefined(right.element, p) : right.element;
+        const after = await this.visitSpace(right.after, p);
+        const markers = await this.visitMarkers(right.markers, p);
+        this.cursor = this.cursor.parent;
+        if (element === undefined) {
+            return undefined;
+        }
+        return (0, util_1.updateIfChanged)(right, { element, after, markers });
+    }
+    async visitOptionalLeftPadded(left, p) {
+        return left ? this.visitLeftPadded(left, p) : undefined;
+    }
+    async visitLeftPadded(left, p) {
+        this.cursor = new tree_1.Cursor(left, this.cursor);
+        const before = await this.visitSpace(left.before, p);
+        let element = left.element;
+        if ((0, tree_1.isTree)(left.element)) {
+            element = await this.visitDefined(left.element, p);
+        }
+        else if ((0, tree_2.isSpace)(left.element)) {
+            element = await this.visitSpace(left.element, p);
+        }
+        const markers = await this.visitMarkers(left.markers, p);
+        this.cursor = this.cursor.parent;
+        if (element === undefined) {
+            return undefined;
+        }
+        return (0, util_1.updateIfChanged)(left, { before, element, markers });
+    }
+    async visitOptionalContainer(container, p) {
+        return container ? this.visitContainer(container, p) : undefined;
+    }
+    async visitContainer(container, p) {
+        this.cursor = new tree_1.Cursor(container, this.cursor);
+        const before = await this.visitSpace(container.before, p);
+        const elements = await (0, util_1.mapAsync)(container.elements, e => this.visitRightPadded(e, p));
+        const markers = await this.visitMarkers(container.markers, p);
+        this.cursor = this.cursor.parent;
+        return (0, util_1.updateIfChanged)(container, { before, elements, markers });
+    }
+    async produceJava(before, p, recipe) {
+        const [draft, finishDraft] = (0, mutative_1.create)(before);
+        draft.prefix = await this.visitSpace(before.prefix, p);
+        draft.markers = await this.visitMarkers(before.markers, p);
+        if (recipe) {
+            await recipe(draft);
+        }
+        return finishDraft();
     }
     accept(t, p) {
         switch (t.kind) {