@openrewrite/rewrite 0.18.0

package/dist/src/java/visitor.js

@@ -0,0 +1,872 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaVisitor = void 0;
+const extensions = __importStar(require("./extensions"));
+const core_1 = require("../core");
+const tree_1 = require("./tree");
+const tree_2 = require("./tree");
+class JavaVisitor extends core_1.TreeVisitor {
+    isAcceptable(sourceFile, p) {
+        return (0, tree_1.isJava)(sourceFile);
+    }
+    visitExpression(expression, p) {
+        return expression;
+    }
+    visitStatement(statement, p) {
+        return statement;
+    }
+    visitAnnotatedType(annotatedType, p) {
+        annotatedType = annotatedType.withPrefix(this.visitSpace(annotatedType.prefix, 1, p));
+        let tempExpression = this.visitExpression(annotatedType, p);
+        if (!(tempExpression instanceof tree_2.AnnotatedType)) {
+            return tempExpression;
+        }
+        annotatedType = tempExpression;
+        annotatedType = annotatedType.withMarkers(this.visitMarkers(annotatedType.markers, p));
+        annotatedType = annotatedType.withAnnotations(core_1.ListUtils.map(annotatedType.annotations, el => this.visitAndCast(el, p)));
+        annotatedType = annotatedType.withTypeExpression(this.visitAndCast(annotatedType.typeExpression, p));
+        return annotatedType;
+    }
+    visitAnnotation(annotation, p) {
+        annotation = annotation.withPrefix(this.visitSpace(annotation.prefix, 5, p));
+        let tempExpression = this.visitExpression(annotation, p);
+        if (!(tempExpression instanceof tree_2.Annotation)) {
+            return tempExpression;
+        }
+        annotation = tempExpression;
+        annotation = annotation.withMarkers(this.visitMarkers(annotation.markers, p));
+        annotation = annotation.withAnnotationType(this.visitAndCast(annotation.annotationType, p));
+        annotation = annotation.padding.withArguments(this.visitContainer(annotation.padding.arguments, tree_1.JContainer.Location.ANNOTATION_ARGUMENTS, p));
+        return annotation;
+    }
+    visitArrayAccess(arrayAccess, p) {
+        arrayAccess = arrayAccess.withPrefix(this.visitSpace(arrayAccess.prefix, 6, p));
+        let tempExpression = this.visitExpression(arrayAccess, p);
+        if (!(tempExpression instanceof tree_2.ArrayAccess)) {
+            return tempExpression;
+        }
+        arrayAccess = tempExpression;
+        arrayAccess = arrayAccess.withMarkers(this.visitMarkers(arrayAccess.markers, p));
+        arrayAccess = arrayAccess.withIndexed(this.visitAndCast(arrayAccess.indexed, p));
+        arrayAccess = arrayAccess.withDimension(this.visitAndCast(arrayAccess.dimension, p));
+        return arrayAccess;
+    }
+    visitArrayType(arrayType, p) {
+        arrayType = arrayType.withPrefix(this.visitSpace(arrayType.prefix, 8, p));
+        let tempExpression = this.visitExpression(arrayType, p);
+        if (!(tempExpression instanceof tree_2.ArrayType)) {
+            return tempExpression;
+        }
+        arrayType = tempExpression;
+        arrayType = arrayType.withMarkers(this.visitMarkers(arrayType.markers, p));
+        arrayType = arrayType.withElementType(this.visitAndCast(arrayType.elementType, p));
+        arrayType = arrayType.withAnnotations(core_1.ListUtils.map(arrayType.annotations, el => this.visitAndCast(el, p)));
+        arrayType = arrayType.withDimension(arrayType.dimension == null ? null : arrayType.dimension.withBefore(this.visitSpace(arrayType.dimension.before, 35, p)).withElement(this.visitSpace(arrayType.dimension.element, 36, p)));
+        return arrayType;
+    }
+    visitAssert(assert, p) {
+        assert = assert.withPrefix(this.visitSpace(assert.prefix, 9, p));
+        let tempStatement = this.visitStatement(assert, p);
+        if (!(tempStatement instanceof tree_2.Assert)) {
+            return tempStatement;
+        }
+        assert = tempStatement;
+        assert = assert.withMarkers(this.visitMarkers(assert.markers, p));
+        assert = assert.withCondition(this.visitAndCast(assert.condition, p));
+        assert = assert.withDetail(this.visitLeftPadded(assert.detail, tree_1.JLeftPadded.Location.ASSERT_DETAIL, p));
+        return assert;
+    }
+    visitAssignment(assignment, p) {
+        assignment = assignment.withPrefix(this.visitSpace(assignment.prefix, 15, p));
+        let tempStatement = this.visitStatement(assignment, p);
+        if (!(tempStatement instanceof tree_2.Assignment)) {
+            return tempStatement;
+        }
+        assignment = tempStatement;
+        let tempExpression = this.visitExpression(assignment, p);
+        if (!(tempExpression instanceof tree_2.Assignment)) {
+            return tempExpression;
+        }
+        assignment = tempExpression;
+        assignment = assignment.withMarkers(this.visitMarkers(assignment.markers, p));
+        assignment = assignment.withVariable(this.visitAndCast(assignment.variable, p));
+        assignment = assignment.padding.withAssignment(this.visitLeftPadded(assignment.padding.assignment, tree_1.JLeftPadded.Location.ASSIGNMENT, p));
+        return assignment;
+    }
+    visitAssignmentOperation(assignmentOperation, p) {
+        assignmentOperation = assignmentOperation.withPrefix(this.visitSpace(assignmentOperation.prefix, 13, p));
+        let tempStatement = this.visitStatement(assignmentOperation, p);
+        if (!(tempStatement instanceof tree_2.AssignmentOperation)) {
+            return tempStatement;
+        }
+        assignmentOperation = tempStatement;
+        let tempExpression = this.visitExpression(assignmentOperation, p);
+        if (!(tempExpression instanceof tree_2.AssignmentOperation)) {
+            return tempExpression;
+        }
+        assignmentOperation = tempExpression;
+        assignmentOperation = assignmentOperation.withMarkers(this.visitMarkers(assignmentOperation.markers, p));
+        assignmentOperation = assignmentOperation.withVariable(this.visitAndCast(assignmentOperation.variable, p));
+        assignmentOperation = assignmentOperation.padding.withOperator(this.visitLeftPadded(assignmentOperation.padding.operator, tree_1.JLeftPadded.Location.ASSIGNMENT_OPERATION_OPERATOR, p));
+        assignmentOperation = assignmentOperation.withAssignment(this.visitAndCast(assignmentOperation.assignment, p));
+        return assignmentOperation;
+    }
+    visitBinary(binary, p) {
+        binary = binary.withPrefix(this.visitSpace(binary.prefix, 17, p));
+        let tempExpression = this.visitExpression(binary, p);
+        if (!(tempExpression instanceof tree_2.Binary)) {
+            return tempExpression;
+        }
+        binary = tempExpression;
+        binary = binary.withMarkers(this.visitMarkers(binary.markers, p));
+        binary = binary.withLeft(this.visitAndCast(binary.left, p));
+        binary = binary.padding.withOperator(this.visitLeftPadded(binary.padding.operator, tree_1.JLeftPadded.Location.BINARY_OPERATOR, p));
+        binary = binary.withRight(this.visitAndCast(binary.right, p));
+        return binary;
+    }
+    visitBlock(block, p) {
+        block = block.withPrefix(this.visitSpace(block.prefix, 19, p));
+        let tempStatement = this.visitStatement(block, p);
+        if (!(tempStatement instanceof tree_2.Block)) {
+            return tempStatement;
+        }
+        block = tempStatement;
+        block = block.withMarkers(this.visitMarkers(block.markers, p));
+        block = block.padding.withStatic(this.visitRightPadded(block.padding.static, tree_1.JRightPadded.Location.STATIC_INIT, p));
+        block = block.padding.withStatements(core_1.ListUtils.map(block.padding.statements, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.BLOCK_STATEMENT, p)));
+        block = block.withEnd(this.visitSpace(block.end, 18, p));
+        return block;
+    }
+    visitBreak(_break, p) {
+        _break = _break.withPrefix(this.visitSpace(_break.prefix, 21, p));
+        let tempStatement = this.visitStatement(_break, p);
+        if (!(tempStatement instanceof tree_2.Break)) {
+            return tempStatement;
+        }
+        _break = tempStatement;
+        _break = _break.withMarkers(this.visitMarkers(_break.markers, p));
+        _break = _break.withLabel(this.visitAndCast(_break.label, p));
+        return _break;
+    }
+    visitCase(_case, p) {
+        _case = _case.withPrefix(this.visitSpace(_case.prefix, 23, p));
+        let tempStatement = this.visitStatement(_case, p);
+        if (!(tempStatement instanceof tree_2.Case)) {
+            return tempStatement;
+        }
+        _case = tempStatement;
+        _case = _case.withMarkers(this.visitMarkers(_case.markers, p));
+        _case = _case.padding.withExpressions(this.visitContainer(_case.padding.expressions, tree_1.JContainer.Location.CASE_EXPRESSION, p));
+        _case = _case.padding.withStatements(this.visitContainer(_case.padding.statements, tree_1.JContainer.Location.CASE, p));
+        _case = _case.padding.withBody(this.visitRightPadded(_case.padding.body, tree_1.JRightPadded.Location.CASE_BODY, p));
+        return _case;
+    }
+    visitClassDeclaration(classDeclaration, p) {
+        classDeclaration = classDeclaration.withPrefix(this.visitSpace(classDeclaration.prefix, 29, p));
+        let tempStatement = this.visitStatement(classDeclaration, p);
+        if (!(tempStatement instanceof tree_2.ClassDeclaration)) {
+            return tempStatement;
+        }
+        classDeclaration = tempStatement;
+        classDeclaration = classDeclaration.withMarkers(this.visitMarkers(classDeclaration.markers, p));
+        classDeclaration = classDeclaration.withLeadingAnnotations(core_1.ListUtils.map(classDeclaration.leadingAnnotations, el => this.visitAndCast(el, p)));
+        classDeclaration = classDeclaration.withModifiers(core_1.ListUtils.map(classDeclaration.modifiers, el => this.visitAndCast(el, p)));
+        classDeclaration = classDeclaration.padding.withKind(this.visitAndCast(classDeclaration.padding.kind, p));
+        classDeclaration = classDeclaration.withName(this.visitAndCast(classDeclaration.name, p));
+        classDeclaration = classDeclaration.padding.withTypeParameters(this.visitContainer(classDeclaration.padding.typeParameters, tree_1.JContainer.Location.TYPE_PARAMETERS, p));
+        classDeclaration = classDeclaration.padding.withPrimaryConstructor(this.visitContainer(classDeclaration.padding.primaryConstructor, tree_1.JContainer.Location.RECORD_STATE_VECTOR, p));
+        classDeclaration = classDeclaration.padding.withExtends(this.visitLeftPadded(classDeclaration.padding.extends, tree_1.JLeftPadded.Location.EXTENDS, p));
+        classDeclaration = classDeclaration.padding.withImplements(this.visitContainer(classDeclaration.padding.implements, tree_1.JContainer.Location.IMPLEMENTS, p));
+        classDeclaration = classDeclaration.padding.withPermits(this.visitContainer(classDeclaration.padding.permits, tree_1.JContainer.Location.PERMITS, p));
+        classDeclaration = classDeclaration.withBody(this.visitAndCast(classDeclaration.body, p));
+        return classDeclaration;
+    }
+    visitClassDeclarationKind(kind, p) {
+        kind = kind.withPrefix(this.visitSpace(kind.prefix, 30, p));
+        kind = kind.withMarkers(this.visitMarkers(kind.markers, p));
+        kind = kind.withAnnotations(core_1.ListUtils.map(kind.annotations, el => this.visitAndCast(el, p)));
+        return kind;
+    }
+    visitCompilationUnit(compilationUnit, p) {
+        compilationUnit = compilationUnit.withPrefix(this.visitSpace(compilationUnit.prefix, 32, p));
+        compilationUnit = compilationUnit.withMarkers(this.visitMarkers(compilationUnit.markers, p));
+        compilationUnit = compilationUnit.padding.withPackageDeclaration(this.visitRightPadded(compilationUnit.padding.packageDeclaration, tree_1.JRightPadded.Location.PACKAGE, p));
+        compilationUnit = compilationUnit.padding.withImports(core_1.ListUtils.map(compilationUnit.padding.imports, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.IMPORT, p)));
+        compilationUnit = compilationUnit.withClasses(core_1.ListUtils.map(compilationUnit.classes, el => this.visitAndCast(el, p)));
+        compilationUnit = compilationUnit.withEof(this.visitSpace(compilationUnit.eof, 31, p));
+        return compilationUnit;
+    }
+    visitContinue(_continue, p) {
+        _continue = _continue.withPrefix(this.visitSpace(_continue.prefix, 33, p));
+        let tempStatement = this.visitStatement(_continue, p);
+        if (!(tempStatement instanceof tree_2.Continue)) {
+            return tempStatement;
+        }
+        _continue = tempStatement;
+        _continue = _continue.withMarkers(this.visitMarkers(_continue.markers, p));
+        _continue = _continue.withLabel(this.visitAndCast(_continue.label, p));
+        return _continue;
+    }
+    visitDoWhileLoop(doWhileLoop, p) {
+        doWhileLoop = doWhileLoop.withPrefix(this.visitSpace(doWhileLoop.prefix, 38, p));
+        let tempStatement = this.visitStatement(doWhileLoop, p);
+        if (!(tempStatement instanceof tree_2.DoWhileLoop)) {
+            return tempStatement;
+        }
+        doWhileLoop = tempStatement;
+        doWhileLoop = doWhileLoop.withMarkers(this.visitMarkers(doWhileLoop.markers, p));
+        doWhileLoop = doWhileLoop.padding.withBody(this.visitRightPadded(doWhileLoop.padding.body, tree_1.JRightPadded.Location.WHILE_BODY, p));
+        doWhileLoop = doWhileLoop.padding.withWhileCondition(this.visitLeftPadded(doWhileLoop.padding.whileCondition, tree_1.JLeftPadded.Location.WHILE_CONDITION, p));
+        return doWhileLoop;
+    }
+    visitEmpty(empty, p) {
+        empty = empty.withPrefix(this.visitSpace(empty.prefix, 40, p));
+        let tempStatement = this.visitStatement(empty, p);
+        if (!(tempStatement instanceof tree_2.Empty)) {
+            return tempStatement;
+        }
+        empty = tempStatement;
+        let tempExpression = this.visitExpression(empty, p);
+        if (!(tempExpression instanceof tree_2.Empty)) {
+            return tempExpression;
+        }
+        empty = tempExpression;
+        empty = empty.withMarkers(this.visitMarkers(empty.markers, p));
+        return empty;
+    }
+    visitEnumValue(enumValue, p) {
+        enumValue = enumValue.withPrefix(this.visitSpace(enumValue.prefix, 41, p));
+        enumValue = enumValue.withMarkers(this.visitMarkers(enumValue.markers, p));
+        enumValue = enumValue.withAnnotations(core_1.ListUtils.map(enumValue.annotations, el => this.visitAndCast(el, p)));
+        enumValue = enumValue.withName(this.visitAndCast(enumValue.name, p));
+        enumValue = enumValue.withInitializer(this.visitAndCast(enumValue.initializer, p));
+        return enumValue;
+    }
+    visitEnumValueSet(enumValueSet, p) {
+        enumValueSet = enumValueSet.withPrefix(this.visitSpace(enumValueSet.prefix, 42, p));
+        let tempStatement = this.visitStatement(enumValueSet, p);
+        if (!(tempStatement instanceof tree_2.EnumValueSet)) {
+            return tempStatement;
+        }
+        enumValueSet = tempStatement;
+        enumValueSet = enumValueSet.withMarkers(this.visitMarkers(enumValueSet.markers, p));
+        enumValueSet = enumValueSet.padding.withEnums(core_1.ListUtils.map(enumValueSet.padding.enums, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.ENUM_VALUE, p)));
+        return enumValueSet;
+    }
+    visitFieldAccess(fieldAccess, p) {
+        fieldAccess = fieldAccess.withPrefix(this.visitSpace(fieldAccess.prefix, 47, p));
+        let tempStatement = this.visitStatement(fieldAccess, p);
+        if (!(tempStatement instanceof tree_2.FieldAccess)) {
+            return tempStatement;
+        }
+        fieldAccess = tempStatement;
+        let tempExpression = this.visitExpression(fieldAccess, p);
+        if (!(tempExpression instanceof tree_2.FieldAccess)) {
+            return tempExpression;
+        }
+        fieldAccess = tempExpression;
+        fieldAccess = fieldAccess.withMarkers(this.visitMarkers(fieldAccess.markers, p));
+        fieldAccess = fieldAccess.withTarget(this.visitAndCast(fieldAccess.target, p));
+        fieldAccess = fieldAccess.padding.withName(this.visitLeftPadded(fieldAccess.padding.name, tree_1.JLeftPadded.Location.FIELD_ACCESS_NAME, p));
+        return fieldAccess;
+    }
+    visitForEachLoop(forEachLoop, p) {
+        forEachLoop = forEachLoop.withPrefix(this.visitSpace(forEachLoop.prefix, 54, p));
+        let tempStatement = this.visitStatement(forEachLoop, p);
+        if (!(tempStatement instanceof tree_2.ForEachLoop)) {
+            return tempStatement;
+        }
+        forEachLoop = tempStatement;
+        forEachLoop = forEachLoop.withMarkers(this.visitMarkers(forEachLoop.markers, p));
+        forEachLoop = forEachLoop.withControl(this.visitAndCast(forEachLoop.control, p));
+        forEachLoop = forEachLoop.padding.withBody(this.visitRightPadded(forEachLoop.padding.body, tree_1.JRightPadded.Location.FOR_BODY, p));
+        return forEachLoop;
+    }
+    visitForEachControl(control, p) {
+        control = control.withPrefix(this.visitSpace(control.prefix, 53, p));
+        control = control.withMarkers(this.visitMarkers(control.markers, p));
+        control = control.padding.withVariable(this.visitRightPadded(control.padding.variable, tree_1.JRightPadded.Location.FOREACH_VARIABLE, p));
+        control = control.padding.withIterable(this.visitRightPadded(control.padding.iterable, tree_1.JRightPadded.Location.FOREACH_ITERABLE, p));
+        return control;
+    }
+    visitForLoop(forLoop, p) {
+        forLoop = forLoop.withPrefix(this.visitSpace(forLoop.prefix, 56, p));
+        let tempStatement = this.visitStatement(forLoop, p);
+        if (!(tempStatement instanceof tree_2.ForLoop)) {
+            return tempStatement;
+        }
+        forLoop = tempStatement;
+        forLoop = forLoop.withMarkers(this.visitMarkers(forLoop.markers, p));
+        forLoop = forLoop.withControl(this.visitAndCast(forLoop.control, p));
+        forLoop = forLoop.padding.withBody(this.visitRightPadded(forLoop.padding.body, tree_1.JRightPadded.Location.FOR_BODY, p));
+        return forLoop;
+    }
+    visitForControl(control, p) {
+        control = control.withPrefix(this.visitSpace(control.prefix, 52, p));
+        control = control.withMarkers(this.visitMarkers(control.markers, p));
+        control = control.padding.withInit(core_1.ListUtils.map(control.padding.init, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.FOR_INIT, p)));
+        control = control.padding.withCondition(this.visitRightPadded(control.padding.condition, tree_1.JRightPadded.Location.FOR_CONDITION, p));
+        control = control.padding.withUpdate(core_1.ListUtils.map(control.padding.update, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.FOR_UPDATE, p)));
+        return control;
+    }
+    visitParenthesizedTypeTree(parenthesizedTypeTree, p) {
+        parenthesizedTypeTree = parenthesizedTypeTree.withPrefix(this.visitSpace(parenthesizedTypeTree.prefix, 107, p));
+        let tempExpression = this.visitExpression(parenthesizedTypeTree, p);
+        if (!(tempExpression instanceof tree_2.ParenthesizedTypeTree)) {
+            return tempExpression;
+        }
+        parenthesizedTypeTree = tempExpression;
+        parenthesizedTypeTree = parenthesizedTypeTree.withMarkers(this.visitMarkers(parenthesizedTypeTree.markers, p));
+        parenthesizedTypeTree = parenthesizedTypeTree.withAnnotations(core_1.ListUtils.map(parenthesizedTypeTree.annotations, el => this.visitAndCast(el, p)));
+        parenthesizedTypeTree = parenthesizedTypeTree.withParenthesizedType(this.visitAndCast(parenthesizedTypeTree.parenthesizedType, p));
+        return parenthesizedTypeTree;
+    }
+    visitIdentifier(identifier, p) {
+        identifier = identifier.withPrefix(this.visitSpace(identifier.prefix, 58, p));
+        let tempExpression = this.visitExpression(identifier, p);
+        if (!(tempExpression instanceof tree_2.Identifier)) {
+            return tempExpression;
+        }
+        identifier = tempExpression;
+        identifier = identifier.withMarkers(this.visitMarkers(identifier.markers, p));
+        identifier = identifier.withAnnotations(core_1.ListUtils.map(identifier.annotations, el => this.visitAndCast(el, p)));
+        return identifier;
+    }
+    visitIf(_if, p) {
+        _if = _if.withPrefix(this.visitSpace(_if.prefix, 60, p));
+        let tempStatement = this.visitStatement(_if, p);
+        if (!(tempStatement instanceof tree_2.If)) {
+            return tempStatement;
+        }
+        _if = tempStatement;
+        _if = _if.withMarkers(this.visitMarkers(_if.markers, p));
+        _if = _if.withIfCondition(this.visitAndCast(_if.ifCondition, p));
+        _if = _if.padding.withThenPart(this.visitRightPadded(_if.padding.thenPart, tree_1.JRightPadded.Location.IF_THEN, p));
+        _if = _if.withElsePart(this.visitAndCast(_if.elsePart, p));
+        return _if;
+    }
+    visitElse(_else, p) {
+        _else = _else.withPrefix(this.visitSpace(_else.prefix, 39, p));
+        _else = _else.withMarkers(this.visitMarkers(_else.markers, p));
+        _else = _else.padding.withBody(this.visitRightPadded(_else.padding.body, tree_1.JRightPadded.Location.IF_ELSE, p));
+        return _else;
+    }
+    visitImport(_import, p) {
+        _import = _import.withPrefix(this.visitSpace(_import.prefix, 66, p));
+        let tempStatement = this.visitStatement(_import, p);
+        if (!(tempStatement instanceof tree_2.Import)) {
+            return tempStatement;
+        }
+        _import = tempStatement;
+        _import = _import.withMarkers(this.visitMarkers(_import.markers, p));
+        _import = _import.padding.withStatic(this.visitLeftPadded(_import.padding.static, tree_1.JLeftPadded.Location.STATIC_IMPORT, p));
+        _import = _import.withQualid(this.visitAndCast(_import.qualid, p));
+        _import = _import.padding.withAlias(this.visitLeftPadded(_import.padding.alias, tree_1.JLeftPadded.Location.IMPORT_ALIAS_PREFIX, p));
+        return _import;
+    }
+    visitInstanceOf(instanceOf, p) {
+        instanceOf = instanceOf.withPrefix(this.visitSpace(instanceOf.prefix, 68, p));
+        let tempExpression = this.visitExpression(instanceOf, p);
+        if (!(tempExpression instanceof tree_2.InstanceOf)) {
+            return tempExpression;
+        }
+        instanceOf = tempExpression;
+        instanceOf = instanceOf.withMarkers(this.visitMarkers(instanceOf.markers, p));
+        instanceOf = instanceOf.padding.withExpression(this.visitRightPadded(instanceOf.padding.expression, tree_1.JRightPadded.Location.INSTANCEOF, p));
+        instanceOf = instanceOf.withClazz(this.visitAndCast(instanceOf.clazz, p));
+        instanceOf = instanceOf.withPattern(this.visitAndCast(instanceOf.pattern, p));
+        return instanceOf;
+    }
+    visitIntersectionType(intersectionType, p) {
+        intersectionType = intersectionType.withPrefix(this.visitSpace(intersectionType.prefix, 70, p));
+        let tempExpression = this.visitExpression(intersectionType, p);
+        if (!(tempExpression instanceof tree_2.IntersectionType)) {
+            return tempExpression;
+        }
+        intersectionType = tempExpression;
+        intersectionType = intersectionType.withMarkers(this.visitMarkers(intersectionType.markers, p));
+        intersectionType = intersectionType.padding.withBounds(this.visitContainer(intersectionType.padding.bounds, tree_1.JContainer.Location.TYPE_BOUNDS, p));
+        return intersectionType;
+    }
+    visitLabel(label, p) {
+        label = label.withPrefix(this.visitSpace(label.prefix, 71, p));
+        let tempStatement = this.visitStatement(label, p);
+        if (!(tempStatement instanceof tree_2.Label)) {
+            return tempStatement;
+        }
+        label = tempStatement;
+        label = label.withMarkers(this.visitMarkers(label.markers, p));
+        label = label.padding.withLabel(this.visitRightPadded(label.padding.label, tree_1.JRightPadded.Location.LABEL, p));
+        label = label.withStatement(this.visitAndCast(label.statement, p));
+        return label;
+    }
+    visitLambda(lambda, p) {
+        lambda = lambda.withPrefix(this.visitSpace(lambda.prefix, 76, p));
+        let tempStatement = this.visitStatement(lambda, p);
+        if (!(tempStatement instanceof tree_2.Lambda)) {
+            return tempStatement;
+        }
+        lambda = tempStatement;
+        let tempExpression = this.visitExpression(lambda, p);
+        if (!(tempExpression instanceof tree_2.Lambda)) {
+            return tempExpression;
+        }
+        lambda = tempExpression;
+        lambda = lambda.withMarkers(this.visitMarkers(lambda.markers, p));
+        lambda = lambda.withParameters(this.visitAndCast(lambda.parameters, p));
+        lambda = lambda.withArrow(this.visitSpace(lambda.arrow, 73, p));
+        lambda = lambda.withBody(this.visitAndCast(lambda.body, p));
+        return lambda;
+    }
+    visitLambdaParameters(parameters, p) {
+        parameters = parameters.withPrefix(this.visitSpace(parameters.prefix, 75, p));
+        parameters = parameters.withMarkers(this.visitMarkers(parameters.markers, p));
+        parameters = parameters.padding.withParameters(core_1.ListUtils.map(parameters.padding.parameters, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.LAMBDA_PARAM, p)));
+        return parameters;
+    }
+    visitLiteral(literal, p) {
+        literal = literal.withPrefix(this.visitSpace(literal.prefix, 78, p));
+        let tempExpression = this.visitExpression(literal, p);
+        if (!(tempExpression instanceof tree_2.Literal)) {
+            return tempExpression;
+        }
+        literal = tempExpression;
+        literal = literal.withMarkers(this.visitMarkers(literal.markers, p));
+        return literal;
+    }
+    visitMemberReference(memberReference, p) {
+        memberReference = memberReference.withPrefix(this.visitSpace(memberReference.prefix, 81, p));
+        let tempExpression = this.visitExpression(memberReference, p);
+        if (!(tempExpression instanceof tree_2.MemberReference)) {
+            return tempExpression;
+        }
+        memberReference = tempExpression;
+        memberReference = memberReference.withMarkers(this.visitMarkers(memberReference.markers, p));
+        memberReference = memberReference.padding.withContaining(this.visitRightPadded(memberReference.padding.containing, tree_1.JRightPadded.Location.MEMBER_REFERENCE_CONTAINING, p));
+        memberReference = memberReference.padding.withTypeParameters(this.visitContainer(memberReference.padding.typeParameters, tree_1.JContainer.Location.TYPE_PARAMETERS, p));
+        memberReference = memberReference.padding.withReference(this.visitLeftPadded(memberReference.padding.reference, tree_1.JLeftPadded.Location.MEMBER_REFERENCE_NAME, p));
+        return memberReference;
+    }
+    visitMethodDeclaration(methodDeclaration, p) {
+        methodDeclaration = methodDeclaration.withPrefix(this.visitSpace(methodDeclaration.prefix, 85, p));
+        let tempStatement = this.visitStatement(methodDeclaration, p);
+        if (!(tempStatement instanceof tree_2.MethodDeclaration)) {
+            return tempStatement;
+        }
+        methodDeclaration = tempStatement;
+        methodDeclaration = methodDeclaration.withMarkers(this.visitMarkers(methodDeclaration.markers, p));
+        methodDeclaration = methodDeclaration.withLeadingAnnotations(core_1.ListUtils.map(methodDeclaration.leadingAnnotations, el => this.visitAndCast(el, p)));
+        methodDeclaration = methodDeclaration.withModifiers(core_1.ListUtils.map(methodDeclaration.modifiers, el => this.visitAndCast(el, p)));
+        methodDeclaration = methodDeclaration.annotations.withTypeParameters(this.visitAndCast(methodDeclaration.annotations.typeParameters, p));
+        methodDeclaration = methodDeclaration.withReturnTypeExpression(this.visitAndCast(methodDeclaration.returnTypeExpression, p));
+        methodDeclaration = methodDeclaration.annotations.withName(methodDeclaration.annotations.name.withAnnotations(core_1.ListUtils.map(methodDeclaration.annotations.name.annotations, el => this.visitAndCast(el, p))).withIdentifier(this.visitAndCast(methodDeclaration.annotations.name.identifier, p)));
+        methodDeclaration = methodDeclaration.padding.withParameters(this.visitContainer(methodDeclaration.padding.parameters, tree_1.JContainer.Location.METHOD_DECLARATION_PARAMETERS, p));
+        methodDeclaration = methodDeclaration.padding.withThrows(this.visitContainer(methodDeclaration.padding.throws, tree_1.JContainer.Location.THROWS, p));
+        methodDeclaration = methodDeclaration.withBody(this.visitAndCast(methodDeclaration.body, p));
+        methodDeclaration = methodDeclaration.padding.withDefaultValue(this.visitLeftPadded(methodDeclaration.padding.defaultValue, tree_1.JLeftPadded.Location.METHOD_DECLARATION_DEFAULT_VALUE, p));
+        return methodDeclaration;
+    }
+    visitMethodInvocation(methodInvocation, p) {
+        methodInvocation = methodInvocation.withPrefix(this.visitSpace(methodInvocation.prefix, 89, p));
+        let tempStatement = this.visitStatement(methodInvocation, p);
+        if (!(tempStatement instanceof tree_2.MethodInvocation)) {
+            return tempStatement;
+        }
+        methodInvocation = tempStatement;
+        let tempExpression = this.visitExpression(methodInvocation, p);
+        if (!(tempExpression instanceof tree_2.MethodInvocation)) {
+            return tempExpression;
+        }
+        methodInvocation = tempExpression;
+        methodInvocation = methodInvocation.withMarkers(this.visitMarkers(methodInvocation.markers, p));
+        methodInvocation = methodInvocation.padding.withSelect(this.visitRightPadded(methodInvocation.padding.select, tree_1.JRightPadded.Location.METHOD_SELECT, p));
+        methodInvocation = methodInvocation.padding.withTypeParameters(this.visitContainer(methodInvocation.padding.typeParameters, tree_1.JContainer.Location.TYPE_PARAMETERS, p));
+        methodInvocation = methodInvocation.withName(this.visitAndCast(methodInvocation.name, p));
+        methodInvocation = methodInvocation.padding.withArguments(this.visitContainer(methodInvocation.padding.arguments, tree_1.JContainer.Location.METHOD_INVOCATION_ARGUMENTS, p));
+        return methodInvocation;
+    }
+    visitModifier(modifier, p) {
+        modifier = modifier.withPrefix(this.visitSpace(modifier.prefix, 91, p));
+        modifier = modifier.withMarkers(this.visitMarkers(modifier.markers, p));
+        modifier = modifier.withAnnotations(core_1.ListUtils.map(modifier.annotations, el => this.visitAndCast(el, p)));
+        return modifier;
+    }
+    visitMultiCatch(multiCatch, p) {
+        multiCatch = multiCatch.withPrefix(this.visitSpace(multiCatch.prefix, 92, p));
+        multiCatch = multiCatch.withMarkers(this.visitMarkers(multiCatch.markers, p));
+        multiCatch = multiCatch.padding.withAlternatives(core_1.ListUtils.map(multiCatch.padding.alternatives, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.CATCH_ALTERNATIVE, p)));
+        return multiCatch;
+    }
+    visitNewArray(newArray, p) {
+        newArray = newArray.withPrefix(this.visitSpace(newArray.prefix, 96, p));
+        let tempExpression = this.visitExpression(newArray, p);
+        if (!(tempExpression instanceof tree_2.NewArray)) {
+            return tempExpression;
+        }
+        newArray = tempExpression;
+        newArray = newArray.withMarkers(this.visitMarkers(newArray.markers, p));
+        newArray = newArray.withTypeExpression(this.visitAndCast(newArray.typeExpression, p));
+        newArray = newArray.withDimensions(core_1.ListUtils.map(newArray.dimensions, el => this.visitAndCast(el, p)));
+        newArray = newArray.padding.withInitializer(this.visitContainer(newArray.padding.initializer, tree_1.JContainer.Location.NEW_ARRAY_INITIALIZER, p));
+        return newArray;
+    }
+    visitArrayDimension(arrayDimension, p) {
+        arrayDimension = arrayDimension.withPrefix(this.visitSpace(arrayDimension.prefix, 35, p));
+        arrayDimension = arrayDimension.withMarkers(this.visitMarkers(arrayDimension.markers, p));
+        arrayDimension = arrayDimension.padding.withIndex(this.visitRightPadded(arrayDimension.padding.index, tree_1.JRightPadded.Location.ARRAY_INDEX, p));
+        return arrayDimension;
+    }
+    visitNewClass(newClass, p) {
+        newClass = newClass.withPrefix(this.visitSpace(newClass.prefix, 100, p));
+        let tempStatement = this.visitStatement(newClass, p);
+        if (!(tempStatement instanceof tree_2.NewClass)) {
+            return tempStatement;
+        }
+        newClass = tempStatement;
+        let tempExpression = this.visitExpression(newClass, p);
+        if (!(tempExpression instanceof tree_2.NewClass)) {
+            return tempExpression;
+        }
+        newClass = tempExpression;
+        newClass = newClass.withMarkers(this.visitMarkers(newClass.markers, p));
+        newClass = newClass.padding.withEnclosing(this.visitRightPadded(newClass.padding.enclosing, tree_1.JRightPadded.Location.NEW_CLASS_ENCLOSING, p));
+        newClass = newClass.withNew(this.visitSpace(newClass.new, 101, p));
+        newClass = newClass.withClazz(this.visitAndCast(newClass.clazz, p));
+        newClass = newClass.padding.withArguments(this.visitContainer(newClass.padding.arguments, tree_1.JContainer.Location.NEW_CLASS_ARGUMENTS, p));
+        newClass = newClass.withBody(this.visitAndCast(newClass.body, p));
+        return newClass;
+    }
+    visitNullableType(nullableType, p) {
+        nullableType = nullableType.withPrefix(this.visitSpace(nullableType.prefix, 102, p));
+        let tempExpression = this.visitExpression(nullableType, p);
+        if (!(tempExpression instanceof tree_2.NullableType)) {
+            return tempExpression;
+        }
+        nullableType = tempExpression;
+        nullableType = nullableType.withMarkers(this.visitMarkers(nullableType.markers, p));
+        nullableType = nullableType.withAnnotations(core_1.ListUtils.map(nullableType.annotations, el => this.visitAndCast(el, p)));
+        nullableType = nullableType.padding.withTypeTree(this.visitRightPadded(nullableType.padding.typeTree, tree_1.JRightPadded.Location.NULLABLE, p));
+        return nullableType;
+    }
+    visitPackage(_package, p) {
+        _package = _package.withPrefix(this.visitSpace(_package.prefix, 104, p));
+        let tempStatement = this.visitStatement(_package, p);
+        if (!(tempStatement instanceof tree_2.Package)) {
+            return tempStatement;
+        }
+        _package = tempStatement;
+        _package = _package.withMarkers(this.visitMarkers(_package.markers, p));
+        _package = _package.withExpression(this.visitAndCast(_package.expression, p));
+        _package = _package.withAnnotations(core_1.ListUtils.map(_package.annotations, el => this.visitAndCast(el, p)));
+        return _package;
+    }
+    visitParameterizedType(parameterizedType, p) {
+        parameterizedType = parameterizedType.withPrefix(this.visitSpace(parameterizedType.prefix, 106, p));
+        let tempExpression = this.visitExpression(parameterizedType, p);
+        if (!(tempExpression instanceof tree_2.ParameterizedType)) {
+            return tempExpression;
+        }
+        parameterizedType = tempExpression;
+        parameterizedType = parameterizedType.withMarkers(this.visitMarkers(parameterizedType.markers, p));
+        parameterizedType = parameterizedType.withClazz(this.visitAndCast(parameterizedType.clazz, p));
+        parameterizedType = parameterizedType.padding.withTypeParameters(this.visitContainer(parameterizedType.padding.typeParameters, tree_1.JContainer.Location.TYPE_PARAMETERS, p));
+        return parameterizedType;
+    }
+    visitParentheses(parentheses, p) {
+        parentheses = parentheses.withPrefix(this.visitSpace(parentheses.prefix, 107, p));
+        let tempExpression = this.visitExpression(parentheses, p);
+        if (!(tempExpression instanceof tree_2.Parentheses)) {
+            return tempExpression;
+        }
+        parentheses = tempExpression;
+        parentheses = parentheses.withMarkers(this.visitMarkers(parentheses.markers, p));
+        parentheses = parentheses.padding.withTree(this.visitRightPadded(parentheses.padding.tree, tree_1.JRightPadded.Location.PARENTHESES, p));
+        return parentheses;
+    }
+    visitControlParentheses(controlParentheses, p) {
+        controlParentheses = controlParentheses.withPrefix(this.visitSpace(controlParentheses.prefix, 34, p));
+        let tempExpression = this.visitExpression(controlParentheses, p);
+        if (!(tempExpression instanceof tree_2.ControlParentheses)) {
+            return tempExpression;
+        }
+        controlParentheses = tempExpression;
+        controlParentheses = controlParentheses.withMarkers(this.visitMarkers(controlParentheses.markers, p));
+        controlParentheses = controlParentheses.padding.withTree(this.visitRightPadded(controlParentheses.padding.tree, tree_1.JRightPadded.Location.PARENTHESES, p));
+        return controlParentheses;
+    }
+    visitPrimitive(primitive, p) {
+        primitive = primitive.withPrefix(this.visitSpace(primitive.prefix, 110, p));
+        let tempExpression = this.visitExpression(primitive, p);
+        if (!(tempExpression instanceof tree_2.Primitive)) {
+            return tempExpression;
+        }
+        primitive = tempExpression;
+        primitive = primitive.withMarkers(this.visitMarkers(primitive.markers, p));
+        return primitive;
+    }
+    visitReturn(_return, p) {
+        _return = _return.withPrefix(this.visitSpace(_return.prefix, 113, p));
+        let tempStatement = this.visitStatement(_return, p);
+        if (!(tempStatement instanceof tree_2.Return)) {
+            return tempStatement;
+        }
+        _return = tempStatement;
+        _return = _return.withMarkers(this.visitMarkers(_return.markers, p));
+        _return = _return.withExpression(this.visitAndCast(_return.expression, p));
+        return _return;
+    }
+    visitSwitch(_switch, p) {
+        _switch = _switch.withPrefix(this.visitSpace(_switch.prefix, 117, p));
+        let tempStatement = this.visitStatement(_switch, p);
+        if (!(tempStatement instanceof tree_2.Switch)) {
+            return tempStatement;
+        }
+        _switch = tempStatement;
+        _switch = _switch.withMarkers(this.visitMarkers(_switch.markers, p));
+        _switch = _switch.withSelector(this.visitAndCast(_switch.selector, p));
+        _switch = _switch.withCases(this.visitAndCast(_switch.cases, p));
+        return _switch;
+    }
+    visitSwitchExpression(switchExpression, p) {
+        switchExpression = switchExpression.withPrefix(this.visitSpace(switchExpression.prefix, 118, p));
+        let tempExpression = this.visitExpression(switchExpression, p);
+        if (!(tempExpression instanceof tree_2.SwitchExpression)) {
+            return tempExpression;
+        }
+        switchExpression = tempExpression;
+        switchExpression = switchExpression.withMarkers(this.visitMarkers(switchExpression.markers, p));
+        switchExpression = switchExpression.withSelector(this.visitAndCast(switchExpression.selector, p));
+        switchExpression = switchExpression.withCases(this.visitAndCast(switchExpression.cases, p));
+        return switchExpression;
+    }
+    visitSynchronized(synchronized, p) {
+        synchronized = synchronized.withPrefix(this.visitSpace(synchronized.prefix, 119, p));
+        let tempStatement = this.visitStatement(synchronized, p);
+        if (!(tempStatement instanceof tree_2.Synchronized)) {
+            return tempStatement;
+        }
+        synchronized = tempStatement;
+        synchronized = synchronized.withMarkers(this.visitMarkers(synchronized.markers, p));
+        synchronized = synchronized.withLock(this.visitAndCast(synchronized.lock, p));
+        synchronized = synchronized.withBody(this.visitAndCast(synchronized.body, p));
+        return synchronized;
+    }
+    visitTernary(ternary, p) {
+        ternary = ternary.withPrefix(this.visitSpace(ternary.prefix, 121, p));
+        let tempStatement = this.visitStatement(ternary, p);
+        if (!(tempStatement instanceof tree_2.Ternary)) {
+            return tempStatement;
+        }
+        ternary = tempStatement;
+        let tempExpression = this.visitExpression(ternary, p);
+        if (!(tempExpression instanceof tree_2.Ternary)) {
+            return tempExpression;
+        }
+        ternary = tempExpression;
+        ternary = ternary.withMarkers(this.visitMarkers(ternary.markers, p));
+        ternary = ternary.withCondition(this.visitAndCast(ternary.condition, p));
+        ternary = ternary.padding.withTruePart(this.visitLeftPadded(ternary.padding.truePart, tree_1.JLeftPadded.Location.TERNARY_TRUE, p));
+        ternary = ternary.padding.withFalsePart(this.visitLeftPadded(ternary.padding.falsePart, tree_1.JLeftPadded.Location.TERNARY_FALSE, p));
+        return ternary;
+    }
+    visitThrow(_throw, p) {
+        _throw = _throw.withPrefix(this.visitSpace(_throw.prefix, 125, p));
+        let tempStatement = this.visitStatement(_throw, p);
+        if (!(tempStatement instanceof tree_2.Throw)) {
+            return tempStatement;
+        }
+        _throw = tempStatement;
+        _throw = _throw.withMarkers(this.visitMarkers(_throw.markers, p));
+        _throw = _throw.withException(this.visitAndCast(_throw.exception, p));
+        return _throw;
+    }
+    visitTry(_try, p) {
+        _try = _try.withPrefix(this.visitSpace(_try.prefix, 127, p));
+        let tempStatement = this.visitStatement(_try, p);
+        if (!(tempStatement instanceof tree_2.Try)) {
+            return tempStatement;
+        }
+        _try = tempStatement;
+        _try = _try.withMarkers(this.visitMarkers(_try.markers, p));
+        _try = _try.padding.withResources(this.visitContainer(_try.padding.resources, tree_1.JContainer.Location.TRY_RESOURCES, p));
+        _try = _try.withBody(this.visitAndCast(_try.body, p));
+        _try = _try.withCatches(core_1.ListUtils.map(_try.catches, el => this.visitAndCast(el, p)));
+        _try = _try.padding.withFinally(this.visitLeftPadded(_try.padding.finally, tree_1.JLeftPadded.Location.TRY_FINALLY, p));
+        return _try;
+    }
+    visitTryResource(resource, p) {
+        resource = resource.withPrefix(this.visitSpace(resource.prefix, 128, p));
+        resource = resource.withMarkers(this.visitMarkers(resource.markers, p));
+        resource = resource.withVariableDeclarations(this.visitAndCast(resource.variableDeclarations, p));
+        return resource;
+    }
+    visitCatch(_catch, p) {
+        _catch = _catch.withPrefix(this.visitSpace(_catch.prefix, 28, p));
+        _catch = _catch.withMarkers(this.visitMarkers(_catch.markers, p));
+        _catch = _catch.withParameter(this.visitAndCast(_catch.parameter, p));
+        _catch = _catch.withBody(this.visitAndCast(_catch.body, p));
+        return _catch;
+    }
+    visitTypeCast(typeCast, p) {
+        typeCast = typeCast.withPrefix(this.visitSpace(typeCast.prefix, 133, p));
+        let tempExpression = this.visitExpression(typeCast, p);
+        if (!(tempExpression instanceof tree_2.TypeCast)) {
+            return tempExpression;
+        }
+        typeCast = tempExpression;
+        typeCast = typeCast.withMarkers(this.visitMarkers(typeCast.markers, p));
+        typeCast = typeCast.withClazz(this.visitAndCast(typeCast.clazz, p));
+        typeCast = typeCast.withExpression(this.visitAndCast(typeCast.expression, p));
+        return typeCast;
+    }
+    visitTypeParameter(typeParameter, p) {
+        typeParameter = typeParameter.withPrefix(this.visitSpace(typeParameter.prefix, 135, p));
+        typeParameter = typeParameter.withMarkers(this.visitMarkers(typeParameter.markers, p));
+        typeParameter = typeParameter.withAnnotations(core_1.ListUtils.map(typeParameter.annotations, el => this.visitAndCast(el, p)));
+        typeParameter = typeParameter.withModifiers(core_1.ListUtils.map(typeParameter.modifiers, el => this.visitAndCast(el, p)));
+        typeParameter = typeParameter.withName(this.visitAndCast(typeParameter.name, p));
+        typeParameter = typeParameter.padding.withBounds(this.visitContainer(typeParameter.padding.bounds, tree_1.JContainer.Location.TYPE_BOUNDS, p));
+        return typeParameter;
+    }
+    visitTypeParameters(typeParameters, p) {
+        typeParameters = typeParameters.withPrefix(this.visitSpace(typeParameters.prefix, 135, p));
+        typeParameters = typeParameters.withMarkers(this.visitMarkers(typeParameters.markers, p));
+        typeParameters = typeParameters.withAnnotations(core_1.ListUtils.map(typeParameters.annotations, el => this.visitAndCast(el, p)));
+        typeParameters = typeParameters.padding.withTypeParameters(core_1.ListUtils.map(typeParameters.padding.typeParameters, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.TYPE_PARAMETER, p)));
+        return typeParameters;
+    }
+    visitUnary(unary, p) {
+        unary = unary.withPrefix(this.visitSpace(unary.prefix, 138, p));
+        let tempStatement = this.visitStatement(unary, p);
+        if (!(tempStatement instanceof tree_2.Unary)) {
+            return tempStatement;
+        }
+        unary = tempStatement;
+        let tempExpression = this.visitExpression(unary, p);
+        if (!(tempExpression instanceof tree_2.Unary)) {
+            return tempExpression;
+        }
+        unary = tempExpression;
+        unary = unary.withMarkers(this.visitMarkers(unary.markers, p));
+        unary = unary.padding.withOperator(this.visitLeftPadded(unary.padding.operator, tree_1.JLeftPadded.Location.UNARY_OPERATOR, p));
+        unary = unary.withExpression(this.visitAndCast(unary.expression, p));
+        return unary;
+    }
+    visitVariableDeclarations(variableDeclarations, p) {
+        variableDeclarations = variableDeclarations.withPrefix(this.visitSpace(variableDeclarations.prefix, 142, p));
+        let tempStatement = this.visitStatement(variableDeclarations, p);
+        if (!(tempStatement instanceof tree_2.VariableDeclarations)) {
+            return tempStatement;
+        }
+        variableDeclarations = tempStatement;
+        variableDeclarations = variableDeclarations.withMarkers(this.visitMarkers(variableDeclarations.markers, p));
+        variableDeclarations = variableDeclarations.withLeadingAnnotations(core_1.ListUtils.map(variableDeclarations.leadingAnnotations, el => this.visitAndCast(el, p)));
+        variableDeclarations = variableDeclarations.withModifiers(core_1.ListUtils.map(variableDeclarations.modifiers, el => this.visitAndCast(el, p)));
+        variableDeclarations = variableDeclarations.withTypeExpression(this.visitAndCast(variableDeclarations.typeExpression, p));
+        variableDeclarations = variableDeclarations.withVarargs(this.visitSpace(variableDeclarations.varargs, 141, p));
+        variableDeclarations = variableDeclarations.withDimensionsBeforeName(core_1.ListUtils.map(variableDeclarations.dimensionsBeforeName, el => el.withBefore(this.visitSpace(el.before, 35, p)).withElement(this.visitSpace(el.element, 36, p))));
+        variableDeclarations = variableDeclarations.padding.withVariables(core_1.ListUtils.map(variableDeclarations.padding.variables, el => this.visitRightPadded(el, tree_1.JRightPadded.Location.NAMED_VARIABLE, p)));
+        return variableDeclarations;
+    }
+    visitVariable(namedVariable, p) {
+        namedVariable = namedVariable.withPrefix(this.visitSpace(namedVariable.prefix, 144, p));
+        namedVariable = namedVariable.withMarkers(this.visitMarkers(namedVariable.markers, p));
+        namedVariable = namedVariable.withName(this.visitAndCast(namedVariable.name, p));
+        namedVariable = namedVariable.withDimensionsAfterName(core_1.ListUtils.map(namedVariable.dimensionsAfterName, el => el.withBefore(this.visitSpace(el.before, 35, p)).withElement(this.visitSpace(el.element, 36, p))));
+        namedVariable = namedVariable.padding.withInitializer(this.visitLeftPadded(namedVariable.padding.initializer, tree_1.JLeftPadded.Location.VARIABLE_INITIALIZER, p));
+        return namedVariable;
+    }
+    visitWhileLoop(whileLoop, p) {
+        whileLoop = whileLoop.withPrefix(this.visitSpace(whileLoop.prefix, 147, p));
+        let tempStatement = this.visitStatement(whileLoop, p);
+        if (!(tempStatement instanceof tree_2.WhileLoop)) {
+            return tempStatement;
+        }
+        whileLoop = tempStatement;
+        whileLoop = whileLoop.withMarkers(this.visitMarkers(whileLoop.markers, p));
+        whileLoop = whileLoop.withCondition(this.visitAndCast(whileLoop.condition, p));
+        whileLoop = whileLoop.padding.withBody(this.visitRightPadded(whileLoop.padding.body, tree_1.JRightPadded.Location.WHILE_BODY, p));
+        return whileLoop;
+    }
+    visitWildcard(wildcard, p) {
+        wildcard = wildcard.withPrefix(this.visitSpace(wildcard.prefix, 149, p));
+        let tempExpression = this.visitExpression(wildcard, p);
+        if (!(tempExpression instanceof tree_2.Wildcard)) {
+            return tempExpression;
+        }
+        wildcard = tempExpression;
+        wildcard = wildcard.withMarkers(this.visitMarkers(wildcard.markers, p));
+        wildcard = wildcard.padding.withBound(this.visitLeftPadded(wildcard.padding.bound, tree_1.JLeftPadded.Location.WILDCARD_BOUND, p));
+        wildcard = wildcard.withBoundedType(this.visitAndCast(wildcard.boundedType, p));
+        return wildcard;
+    }
+    visitYield(_yield, p) {
+        _yield = _yield.withPrefix(this.visitSpace(_yield.prefix, 150, p));
+        let tempStatement = this.visitStatement(_yield, p);
+        if (!(tempStatement instanceof tree_2.Yield)) {
+            return tempStatement;
+        }
+        _yield = tempStatement;
+        _yield = _yield.withMarkers(this.visitMarkers(_yield.markers, p));
+        _yield = _yield.withValue(this.visitAndCast(_yield.value, p));
+        return _yield;
+    }
+    visitUnknown(unknown, p) {
+        unknown = unknown.withPrefix(this.visitSpace(unknown.prefix, 139, p));
+        let tempStatement = this.visitStatement(unknown, p);
+        if (!(tempStatement instanceof tree_2.Unknown)) {
+            return tempStatement;
+        }
+        unknown = tempStatement;
+        let tempExpression = this.visitExpression(unknown, p);
+        if (!(tempExpression instanceof tree_2.Unknown)) {
+            return tempExpression;
+        }
+        unknown = tempExpression;
+        unknown = unknown.withMarkers(this.visitMarkers(unknown.markers, p));
+        unknown = unknown.withSource(this.visitAndCast(unknown.source, p));
+        return unknown;
+    }
+    visitUnknownSource(source, p) {
+        source = source.withPrefix(this.visitSpace(source.prefix, 140, p));
+        source = source.withMarkers(this.visitMarkers(source.markers, p));
+        return source;
+    }
+    visitContainer(container, loc, p) {
+        return extensions.visitContainer(this, container, loc, p);
+    }
+    visitLeftPadded(left, loc, p) {
+        return extensions.visitLeftPadded(this, left, loc, p);
+    }
+    visitRightPadded(right, loc, p) {
+        return extensions.visitRightPadded(this, right, loc, p);
+    }
+    visitSpace(space, loc, p) {
+        return extensions.visitSpace(this, space, loc, p);
+    }
+}
+exports.JavaVisitor = JavaVisitor;
+//# sourceMappingURL=visitor.js.map