@openrewrite/rewrite 0.18.4 → 0.18.6

package/dist/src/java/remote/receiver.js

@@ -0,0 +1,909 @@
+"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.JavaReceiver = void 0;
+const extensions = __importStar(require("./remote_extensions"));
+const core_1 = require("../../core");
+const visitor_1 = require("../visitor");
+const tree_1 = require("../tree");
+const Java = __importStar(require("../tree"));
+class JavaReceiver {
+    fork(ctx) {
+        return ctx.fork(new Visitor(), new Factory());
+    }
+    receive(before, ctx) {
+        let forked = this.fork(ctx);
+        return forked.visitor.visit(before, forked);
+    }
+}
+exports.JavaReceiver = JavaReceiver;
+class Visitor extends visitor_1.JavaVisitor {
+    visit(tree, ctx) {
+        this.cursor = new core_1.Cursor(this.cursor, tree);
+        tree = ctx.receiveNode(tree, ctx.receiveTree);
+        this.cursor = this.cursor.parent;
+        return tree;
+    }
+    visitAnnotatedType(annotatedType, ctx) {
+        annotatedType = annotatedType.withId(ctx.receiveValue(annotatedType.id, 0));
+        annotatedType = annotatedType.withPrefix(ctx.receiveNode(annotatedType.prefix, receiveSpace));
+        annotatedType = annotatedType.withMarkers(ctx.receiveNode(annotatedType.markers, ctx.receiveMarkers));
+        annotatedType = annotatedType.withAnnotations(ctx.receiveNodes(annotatedType.annotations, ctx.receiveTree));
+        annotatedType = annotatedType.withTypeExpression(ctx.receiveNode(annotatedType.typeExpression, ctx.receiveTree));
+        return annotatedType;
+    }
+    visitAnnotation(annotation, ctx) {
+        annotation = annotation.withId(ctx.receiveValue(annotation.id, 0));
+        annotation = annotation.withPrefix(ctx.receiveNode(annotation.prefix, receiveSpace));
+        annotation = annotation.withMarkers(ctx.receiveNode(annotation.markers, ctx.receiveMarkers));
+        annotation = annotation.withAnnotationType(ctx.receiveNode(annotation.annotationType, ctx.receiveTree));
+        annotation = annotation.padding.withArguments(ctx.receiveNode(annotation.padding.arguments, receiveContainer));
+        return annotation;
+    }
+    visitArrayAccess(arrayAccess, ctx) {
+        arrayAccess = arrayAccess.withId(ctx.receiveValue(arrayAccess.id, 0));
+        arrayAccess = arrayAccess.withPrefix(ctx.receiveNode(arrayAccess.prefix, receiveSpace));
+        arrayAccess = arrayAccess.withMarkers(ctx.receiveNode(arrayAccess.markers, ctx.receiveMarkers));
+        arrayAccess = arrayAccess.withIndexed(ctx.receiveNode(arrayAccess.indexed, ctx.receiveTree));
+        arrayAccess = arrayAccess.withDimension(ctx.receiveNode(arrayAccess.dimension, ctx.receiveTree));
+        arrayAccess = arrayAccess.withType(ctx.receiveValue(arrayAccess.type, 5));
+        return arrayAccess;
+    }
+    visitArrayType(arrayType, ctx) {
+        arrayType = arrayType.withId(ctx.receiveValue(arrayType.id, 0));
+        arrayType = arrayType.withPrefix(ctx.receiveNode(arrayType.prefix, receiveSpace));
+        arrayType = arrayType.withMarkers(ctx.receiveNode(arrayType.markers, ctx.receiveMarkers));
+        arrayType = arrayType.withElementType(ctx.receiveNode(arrayType.elementType, ctx.receiveTree));
+        arrayType = arrayType.withAnnotations(ctx.receiveNodes(arrayType.annotations, ctx.receiveTree));
+        arrayType = arrayType.withDimension(ctx.receiveNode(arrayType.dimension, leftPaddedNodeReceiver(tree_1.Space)));
+        arrayType = arrayType.withType(ctx.receiveValue(arrayType.type, 5));
+        return arrayType;
+    }
+    visitAssert(assert, ctx) {
+        assert = assert.withId(ctx.receiveValue(assert.id, 0));
+        assert = assert.withPrefix(ctx.receiveNode(assert.prefix, receiveSpace));
+        assert = assert.withMarkers(ctx.receiveNode(assert.markers, ctx.receiveMarkers));
+        assert = assert.withCondition(ctx.receiveNode(assert.condition, ctx.receiveTree));
+        assert = assert.withDetail(ctx.receiveNode(assert.detail, receiveLeftPaddedTree));
+        return assert;
+    }
+    visitAssignment(assignment, ctx) {
+        assignment = assignment.withId(ctx.receiveValue(assignment.id, 0));
+        assignment = assignment.withPrefix(ctx.receiveNode(assignment.prefix, receiveSpace));
+        assignment = assignment.withMarkers(ctx.receiveNode(assignment.markers, ctx.receiveMarkers));
+        assignment = assignment.withVariable(ctx.receiveNode(assignment.variable, ctx.receiveTree));
+        assignment = assignment.padding.withAssignment(ctx.receiveNode(assignment.padding.assignment, receiveLeftPaddedTree));
+        assignment = assignment.withType(ctx.receiveValue(assignment.type, 5));
+        return assignment;
+    }
+    visitAssignmentOperation(assignmentOperation, ctx) {
+        assignmentOperation = assignmentOperation.withId(ctx.receiveValue(assignmentOperation.id, 0));
+        assignmentOperation = assignmentOperation.withPrefix(ctx.receiveNode(assignmentOperation.prefix, receiveSpace));
+        assignmentOperation = assignmentOperation.withMarkers(ctx.receiveNode(assignmentOperation.markers, ctx.receiveMarkers));
+        assignmentOperation = assignmentOperation.withVariable(ctx.receiveNode(assignmentOperation.variable, ctx.receiveTree));
+        assignmentOperation = assignmentOperation.padding.withOperator(ctx.receiveNode(assignmentOperation.padding.operator, leftPaddedValueReceiver(3)));
+        assignmentOperation = assignmentOperation.withAssignment(ctx.receiveNode(assignmentOperation.assignment, ctx.receiveTree));
+        assignmentOperation = assignmentOperation.withType(ctx.receiveValue(assignmentOperation.type, 5));
+        return assignmentOperation;
+    }
+    visitBinary(binary, ctx) {
+        binary = binary.withId(ctx.receiveValue(binary.id, 0));
+        binary = binary.withPrefix(ctx.receiveNode(binary.prefix, receiveSpace));
+        binary = binary.withMarkers(ctx.receiveNode(binary.markers, ctx.receiveMarkers));
+        binary = binary.withLeft(ctx.receiveNode(binary.left, ctx.receiveTree));
+        binary = binary.padding.withOperator(ctx.receiveNode(binary.padding.operator, leftPaddedValueReceiver(3)));
+        binary = binary.withRight(ctx.receiveNode(binary.right, ctx.receiveTree));
+        binary = binary.withType(ctx.receiveValue(binary.type, 5));
+        return binary;
+    }
+    visitBlock(block, ctx) {
+        block = block.withId(ctx.receiveValue(block.id, 0));
+        block = block.withPrefix(ctx.receiveNode(block.prefix, receiveSpace));
+        block = block.withMarkers(ctx.receiveNode(block.markers, ctx.receiveMarkers));
+        block = block.padding.withStatic(ctx.receiveNode(block.padding.static, rightPaddedValueReceiver(1)));
+        block = block.padding.withStatements(ctx.receiveNodes(block.padding.statements, receiveRightPaddedTree));
+        block = block.withEnd(ctx.receiveNode(block.end, receiveSpace));
+        return block;
+    }
+    visitBreak(_break, ctx) {
+        _break = _break.withId(ctx.receiveValue(_break.id, 0));
+        _break = _break.withPrefix(ctx.receiveNode(_break.prefix, receiveSpace));
+        _break = _break.withMarkers(ctx.receiveNode(_break.markers, ctx.receiveMarkers));
+        _break = _break.withLabel(ctx.receiveNode(_break.label, ctx.receiveTree));
+        return _break;
+    }
+    visitCase(_case, ctx) {
+        _case = _case.withId(ctx.receiveValue(_case.id, 0));
+        _case = _case.withPrefix(ctx.receiveNode(_case.prefix, receiveSpace));
+        _case = _case.withMarkers(ctx.receiveNode(_case.markers, ctx.receiveMarkers));
+        _case = _case.withType(ctx.receiveValue(_case.type, 3));
+        _case = _case.padding.withExpressions(ctx.receiveNode(_case.padding.expressions, receiveContainer));
+        _case = _case.padding.withStatements(ctx.receiveNode(_case.padding.statements, receiveContainer));
+        _case = _case.padding.withBody(ctx.receiveNode(_case.padding.body, receiveRightPaddedTree));
+        return _case;
+    }
+    visitClassDeclaration(classDeclaration, ctx) {
+        classDeclaration = classDeclaration.withId(ctx.receiveValue(classDeclaration.id, 0));
+        classDeclaration = classDeclaration.withPrefix(ctx.receiveNode(classDeclaration.prefix, receiveSpace));
+        classDeclaration = classDeclaration.withMarkers(ctx.receiveNode(classDeclaration.markers, ctx.receiveMarkers));
+        classDeclaration = classDeclaration.withLeadingAnnotations(ctx.receiveNodes(classDeclaration.leadingAnnotations, ctx.receiveTree));
+        classDeclaration = classDeclaration.withModifiers(ctx.receiveNodes(classDeclaration.modifiers, ctx.receiveTree));
+        classDeclaration = classDeclaration.padding.withKind(ctx.receiveNode(classDeclaration.padding.kind, ctx.receiveTree));
+        classDeclaration = classDeclaration.withName(ctx.receiveNode(classDeclaration.name, ctx.receiveTree));
+        classDeclaration = classDeclaration.padding.withTypeParameters(ctx.receiveNode(classDeclaration.padding.typeParameters, receiveContainer));
+        classDeclaration = classDeclaration.padding.withPrimaryConstructor(ctx.receiveNode(classDeclaration.padding.primaryConstructor, receiveContainer));
+        classDeclaration = classDeclaration.padding.withExtends(ctx.receiveNode(classDeclaration.padding.extends, receiveLeftPaddedTree));
+        classDeclaration = classDeclaration.padding.withImplements(ctx.receiveNode(classDeclaration.padding.implements, receiveContainer));
+        classDeclaration = classDeclaration.padding.withPermits(ctx.receiveNode(classDeclaration.padding.permits, receiveContainer));
+        classDeclaration = classDeclaration.withBody(ctx.receiveNode(classDeclaration.body, ctx.receiveTree));
+        classDeclaration = classDeclaration.withType(ctx.receiveValue(classDeclaration.type, 5));
+        return classDeclaration;
+    }
+    visitClassDeclarationKind(kind, ctx) {
+        kind = kind.withId(ctx.receiveValue(kind.id, 0));
+        kind = kind.withPrefix(ctx.receiveNode(kind.prefix, receiveSpace));
+        kind = kind.withMarkers(ctx.receiveNode(kind.markers, ctx.receiveMarkers));
+        kind = kind.withAnnotations(ctx.receiveNodes(kind.annotations, ctx.receiveTree));
+        kind = kind.withType(ctx.receiveValue(kind.type, 3));
+        return kind;
+    }
+    visitCompilationUnit(compilationUnit, ctx) {
+        compilationUnit = compilationUnit.withId(ctx.receiveValue(compilationUnit.id, 0));
+        compilationUnit = compilationUnit.withPrefix(ctx.receiveNode(compilationUnit.prefix, receiveSpace));
+        compilationUnit = compilationUnit.withMarkers(ctx.receiveNode(compilationUnit.markers, ctx.receiveMarkers));
+        compilationUnit = compilationUnit.withSourcePath(ctx.receiveValue(compilationUnit.sourcePath, 1));
+        compilationUnit = compilationUnit.withFileAttributes(ctx.receiveValue(compilationUnit.fileAttributes, 5));
+        compilationUnit = compilationUnit.withCharsetName(ctx.receiveValue(compilationUnit.charsetName, 1));
+        compilationUnit = compilationUnit.withCharsetBomMarked(ctx.receiveValue(compilationUnit.charsetBomMarked, 1));
+        compilationUnit = compilationUnit.withChecksum(ctx.receiveValue(compilationUnit.checksum, 5));
+        compilationUnit = compilationUnit.padding.withPackageDeclaration(ctx.receiveNode(compilationUnit.padding.packageDeclaration, receiveRightPaddedTree));
+        compilationUnit = compilationUnit.padding.withImports(ctx.receiveNodes(compilationUnit.padding.imports, receiveRightPaddedTree));
+        compilationUnit = compilationUnit.withClasses(ctx.receiveNodes(compilationUnit.classes, ctx.receiveTree));
+        compilationUnit = compilationUnit.withEof(ctx.receiveNode(compilationUnit.eof, receiveSpace));
+        return compilationUnit;
+    }
+    visitContinue(_continue, ctx) {
+        _continue = _continue.withId(ctx.receiveValue(_continue.id, 0));
+        _continue = _continue.withPrefix(ctx.receiveNode(_continue.prefix, receiveSpace));
+        _continue = _continue.withMarkers(ctx.receiveNode(_continue.markers, ctx.receiveMarkers));
+        _continue = _continue.withLabel(ctx.receiveNode(_continue.label, ctx.receiveTree));
+        return _continue;
+    }
+    visitDoWhileLoop(doWhileLoop, ctx) {
+        doWhileLoop = doWhileLoop.withId(ctx.receiveValue(doWhileLoop.id, 0));
+        doWhileLoop = doWhileLoop.withPrefix(ctx.receiveNode(doWhileLoop.prefix, receiveSpace));
+        doWhileLoop = doWhileLoop.withMarkers(ctx.receiveNode(doWhileLoop.markers, ctx.receiveMarkers));
+        doWhileLoop = doWhileLoop.padding.withBody(ctx.receiveNode(doWhileLoop.padding.body, receiveRightPaddedTree));
+        doWhileLoop = doWhileLoop.padding.withWhileCondition(ctx.receiveNode(doWhileLoop.padding.whileCondition, receiveLeftPaddedTree));
+        return doWhileLoop;
+    }
+    visitEmpty(empty, ctx) {
+        empty = empty.withId(ctx.receiveValue(empty.id, 0));
+        empty = empty.withPrefix(ctx.receiveNode(empty.prefix, receiveSpace));
+        empty = empty.withMarkers(ctx.receiveNode(empty.markers, ctx.receiveMarkers));
+        return empty;
+    }
+    visitEnumValue(enumValue, ctx) {
+        enumValue = enumValue.withId(ctx.receiveValue(enumValue.id, 0));
+        enumValue = enumValue.withPrefix(ctx.receiveNode(enumValue.prefix, receiveSpace));
+        enumValue = enumValue.withMarkers(ctx.receiveNode(enumValue.markers, ctx.receiveMarkers));
+        enumValue = enumValue.withAnnotations(ctx.receiveNodes(enumValue.annotations, ctx.receiveTree));
+        enumValue = enumValue.withName(ctx.receiveNode(enumValue.name, ctx.receiveTree));
+        enumValue = enumValue.withInitializer(ctx.receiveNode(enumValue.initializer, ctx.receiveTree));
+        return enumValue;
+    }
+    visitEnumValueSet(enumValueSet, ctx) {
+        enumValueSet = enumValueSet.withId(ctx.receiveValue(enumValueSet.id, 0));
+        enumValueSet = enumValueSet.withPrefix(ctx.receiveNode(enumValueSet.prefix, receiveSpace));
+        enumValueSet = enumValueSet.withMarkers(ctx.receiveNode(enumValueSet.markers, ctx.receiveMarkers));
+        enumValueSet = enumValueSet.padding.withEnums(ctx.receiveNodes(enumValueSet.padding.enums, receiveRightPaddedTree));
+        enumValueSet = enumValueSet.withTerminatedWithSemicolon(ctx.receiveValue(enumValueSet.terminatedWithSemicolon, 1));
+        return enumValueSet;
+    }
+    visitFieldAccess(fieldAccess, ctx) {
+        fieldAccess = fieldAccess.withId(ctx.receiveValue(fieldAccess.id, 0));
+        fieldAccess = fieldAccess.withPrefix(ctx.receiveNode(fieldAccess.prefix, receiveSpace));
+        fieldAccess = fieldAccess.withMarkers(ctx.receiveNode(fieldAccess.markers, ctx.receiveMarkers));
+        fieldAccess = fieldAccess.withTarget(ctx.receiveNode(fieldAccess.target, ctx.receiveTree));
+        fieldAccess = fieldAccess.padding.withName(ctx.receiveNode(fieldAccess.padding.name, receiveLeftPaddedTree));
+        fieldAccess = fieldAccess.withType(ctx.receiveValue(fieldAccess.type, 5));
+        return fieldAccess;
+    }
+    visitForEachLoop(forEachLoop, ctx) {
+        forEachLoop = forEachLoop.withId(ctx.receiveValue(forEachLoop.id, 0));
+        forEachLoop = forEachLoop.withPrefix(ctx.receiveNode(forEachLoop.prefix, receiveSpace));
+        forEachLoop = forEachLoop.withMarkers(ctx.receiveNode(forEachLoop.markers, ctx.receiveMarkers));
+        forEachLoop = forEachLoop.withControl(ctx.receiveNode(forEachLoop.control, ctx.receiveTree));
+        forEachLoop = forEachLoop.padding.withBody(ctx.receiveNode(forEachLoop.padding.body, receiveRightPaddedTree));
+        return forEachLoop;
+    }
+    visitForEachControl(control, ctx) {
+        control = control.withId(ctx.receiveValue(control.id, 0));
+        control = control.withPrefix(ctx.receiveNode(control.prefix, receiveSpace));
+        control = control.withMarkers(ctx.receiveNode(control.markers, ctx.receiveMarkers));
+        control = control.padding.withVariable(ctx.receiveNode(control.padding.variable, receiveRightPaddedTree));
+        control = control.padding.withIterable(ctx.receiveNode(control.padding.iterable, receiveRightPaddedTree));
+        return control;
+    }
+    visitForLoop(forLoop, ctx) {
+        forLoop = forLoop.withId(ctx.receiveValue(forLoop.id, 0));
+        forLoop = forLoop.withPrefix(ctx.receiveNode(forLoop.prefix, receiveSpace));
+        forLoop = forLoop.withMarkers(ctx.receiveNode(forLoop.markers, ctx.receiveMarkers));
+        forLoop = forLoop.withControl(ctx.receiveNode(forLoop.control, ctx.receiveTree));
+        forLoop = forLoop.padding.withBody(ctx.receiveNode(forLoop.padding.body, receiveRightPaddedTree));
+        return forLoop;
+    }
+    visitForControl(control, ctx) {
+        control = control.withId(ctx.receiveValue(control.id, 0));
+        control = control.withPrefix(ctx.receiveNode(control.prefix, receiveSpace));
+        control = control.withMarkers(ctx.receiveNode(control.markers, ctx.receiveMarkers));
+        control = control.padding.withInit(ctx.receiveNodes(control.padding.init, receiveRightPaddedTree));
+        control = control.padding.withCondition(ctx.receiveNode(control.padding.condition, receiveRightPaddedTree));
+        control = control.padding.withUpdate(ctx.receiveNodes(control.padding.update, receiveRightPaddedTree));
+        return control;
+    }
+    visitParenthesizedTypeTree(parenthesizedTypeTree, ctx) {
+        parenthesizedTypeTree = parenthesizedTypeTree.withId(ctx.receiveValue(parenthesizedTypeTree.id, 0));
+        parenthesizedTypeTree = parenthesizedTypeTree.withPrefix(ctx.receiveNode(parenthesizedTypeTree.prefix, receiveSpace));
+        parenthesizedTypeTree = parenthesizedTypeTree.withMarkers(ctx.receiveNode(parenthesizedTypeTree.markers, ctx.receiveMarkers));
+        parenthesizedTypeTree = parenthesizedTypeTree.withAnnotations(ctx.receiveNodes(parenthesizedTypeTree.annotations, ctx.receiveTree));
+        parenthesizedTypeTree = parenthesizedTypeTree.withParenthesizedType(ctx.receiveNode(parenthesizedTypeTree.parenthesizedType, ctx.receiveTree));
+        return parenthesizedTypeTree;
+    }
+    visitIdentifier(identifier, ctx) {
+        identifier = identifier.withId(ctx.receiveValue(identifier.id, 0));
+        identifier = identifier.withPrefix(ctx.receiveNode(identifier.prefix, receiveSpace));
+        identifier = identifier.withMarkers(ctx.receiveNode(identifier.markers, ctx.receiveMarkers));
+        identifier = identifier.withAnnotations(ctx.receiveNodes(identifier.annotations, ctx.receiveTree));
+        identifier = identifier.withSimpleName(ctx.receiveValue(identifier.simpleName, 1));
+        identifier = identifier.withType(ctx.receiveValue(identifier.type, 5));
+        identifier = identifier.withFieldType(ctx.receiveValue(identifier.fieldType, 5));
+        return identifier;
+    }
+    visitIf(_if, ctx) {
+        _if = _if.withId(ctx.receiveValue(_if.id, 0));
+        _if = _if.withPrefix(ctx.receiveNode(_if.prefix, receiveSpace));
+        _if = _if.withMarkers(ctx.receiveNode(_if.markers, ctx.receiveMarkers));
+        _if = _if.withIfCondition(ctx.receiveNode(_if.ifCondition, ctx.receiveTree));
+        _if = _if.padding.withThenPart(ctx.receiveNode(_if.padding.thenPart, receiveRightPaddedTree));
+        _if = _if.withElsePart(ctx.receiveNode(_if.elsePart, ctx.receiveTree));
+        return _if;
+    }
+    visitElse(_else, ctx) {
+        _else = _else.withId(ctx.receiveValue(_else.id, 0));
+        _else = _else.withPrefix(ctx.receiveNode(_else.prefix, receiveSpace));
+        _else = _else.withMarkers(ctx.receiveNode(_else.markers, ctx.receiveMarkers));
+        _else = _else.padding.withBody(ctx.receiveNode(_else.padding.body, receiveRightPaddedTree));
+        return _else;
+    }
+    visitImport(_import, ctx) {
+        _import = _import.withId(ctx.receiveValue(_import.id, 0));
+        _import = _import.withPrefix(ctx.receiveNode(_import.prefix, receiveSpace));
+        _import = _import.withMarkers(ctx.receiveNode(_import.markers, ctx.receiveMarkers));
+        _import = _import.padding.withStatic(ctx.receiveNode(_import.padding.static, leftPaddedValueReceiver(1)));
+        _import = _import.withQualid(ctx.receiveNode(_import.qualid, ctx.receiveTree));
+        _import = _import.padding.withAlias(ctx.receiveNode(_import.padding.alias, receiveLeftPaddedTree));
+        return _import;
+    }
+    visitInstanceOf(instanceOf, ctx) {
+        instanceOf = instanceOf.withId(ctx.receiveValue(instanceOf.id, 0));
+        instanceOf = instanceOf.withPrefix(ctx.receiveNode(instanceOf.prefix, receiveSpace));
+        instanceOf = instanceOf.withMarkers(ctx.receiveNode(instanceOf.markers, ctx.receiveMarkers));
+        instanceOf = instanceOf.padding.withExpression(ctx.receiveNode(instanceOf.padding.expression, receiveRightPaddedTree));
+        instanceOf = instanceOf.withClazz(ctx.receiveNode(instanceOf.clazz, ctx.receiveTree));
+        instanceOf = instanceOf.withPattern(ctx.receiveNode(instanceOf.pattern, ctx.receiveTree));
+        instanceOf = instanceOf.withType(ctx.receiveValue(instanceOf.type, 5));
+        return instanceOf;
+    }
+    visitIntersectionType(intersectionType, ctx) {
+        intersectionType = intersectionType.withId(ctx.receiveValue(intersectionType.id, 0));
+        intersectionType = intersectionType.withPrefix(ctx.receiveNode(intersectionType.prefix, receiveSpace));
+        intersectionType = intersectionType.withMarkers(ctx.receiveNode(intersectionType.markers, ctx.receiveMarkers));
+        intersectionType = intersectionType.padding.withBounds(ctx.receiveNode(intersectionType.padding.bounds, receiveContainer));
+        return intersectionType;
+    }
+    visitLabel(label, ctx) {
+        label = label.withId(ctx.receiveValue(label.id, 0));
+        label = label.withPrefix(ctx.receiveNode(label.prefix, receiveSpace));
+        label = label.withMarkers(ctx.receiveNode(label.markers, ctx.receiveMarkers));
+        label = label.padding.withLabel(ctx.receiveNode(label.padding.label, receiveRightPaddedTree));
+        label = label.withStatement(ctx.receiveNode(label.statement, ctx.receiveTree));
+        return label;
+    }
+    visitLambda(lambda, ctx) {
+        lambda = lambda.withId(ctx.receiveValue(lambda.id, 0));
+        lambda = lambda.withPrefix(ctx.receiveNode(lambda.prefix, receiveSpace));
+        lambda = lambda.withMarkers(ctx.receiveNode(lambda.markers, ctx.receiveMarkers));
+        lambda = lambda.withParameters(ctx.receiveNode(lambda.parameters, ctx.receiveTree));
+        lambda = lambda.withArrow(ctx.receiveNode(lambda.arrow, receiveSpace));
+        lambda = lambda.withBody(ctx.receiveNode(lambda.body, ctx.receiveTree));
+        lambda = lambda.withType(ctx.receiveValue(lambda.type, 5));
+        return lambda;
+    }
+    visitLambdaParameters(parameters, ctx) {
+        parameters = parameters.withId(ctx.receiveValue(parameters.id, 0));
+        parameters = parameters.withPrefix(ctx.receiveNode(parameters.prefix, receiveSpace));
+        parameters = parameters.withMarkers(ctx.receiveNode(parameters.markers, ctx.receiveMarkers));
+        parameters = parameters.withParenthesized(ctx.receiveValue(parameters.parenthesized, 1));
+        parameters = parameters.padding.withParameters(ctx.receiveNodes(parameters.padding.parameters, receiveRightPaddedTree));
+        return parameters;
+    }
+    visitLiteral(literal, ctx) {
+        literal = literal.withId(ctx.receiveValue(literal.id, 0));
+        literal = literal.withPrefix(ctx.receiveNode(literal.prefix, receiveSpace));
+        literal = literal.withMarkers(ctx.receiveNode(literal.markers, ctx.receiveMarkers));
+        literal = literal.withValue(ctx.receiveValue(literal.value, 5));
+        literal = literal.withValueSource(ctx.receiveValue(literal.valueSource, 1));
+        literal = literal.withUnicodeEscapes(ctx.receiveValues(literal.unicodeEscapes, 5));
+        literal = literal.withType(ctx.receiveValue(literal.type, 3));
+        return literal;
+    }
+    visitMemberReference(memberReference, ctx) {
+        memberReference = memberReference.withId(ctx.receiveValue(memberReference.id, 0));
+        memberReference = memberReference.withPrefix(ctx.receiveNode(memberReference.prefix, receiveSpace));
+        memberReference = memberReference.withMarkers(ctx.receiveNode(memberReference.markers, ctx.receiveMarkers));
+        memberReference = memberReference.padding.withContaining(ctx.receiveNode(memberReference.padding.containing, receiveRightPaddedTree));
+        memberReference = memberReference.padding.withTypeParameters(ctx.receiveNode(memberReference.padding.typeParameters, receiveContainer));
+        memberReference = memberReference.padding.withReference(ctx.receiveNode(memberReference.padding.reference, receiveLeftPaddedTree));
+        memberReference = memberReference.withType(ctx.receiveValue(memberReference.type, 5));
+        memberReference = memberReference.withMethodType(ctx.receiveValue(memberReference.methodType, 5));
+        memberReference = memberReference.withVariableType(ctx.receiveValue(memberReference.variableType, 5));
+        return memberReference;
+    }
+    visitMethodDeclaration(methodDeclaration, ctx) {
+        methodDeclaration = methodDeclaration.withId(ctx.receiveValue(methodDeclaration.id, 0));
+        methodDeclaration = methodDeclaration.withPrefix(ctx.receiveNode(methodDeclaration.prefix, receiveSpace));
+        methodDeclaration = methodDeclaration.withMarkers(ctx.receiveNode(methodDeclaration.markers, ctx.receiveMarkers));
+        methodDeclaration = methodDeclaration.withLeadingAnnotations(ctx.receiveNodes(methodDeclaration.leadingAnnotations, ctx.receiveTree));
+        methodDeclaration = methodDeclaration.withModifiers(ctx.receiveNodes(methodDeclaration.modifiers, ctx.receiveTree));
+        methodDeclaration = methodDeclaration.annotations.withTypeParameters(ctx.receiveNode(methodDeclaration.annotations.typeParameters, ctx.receiveTree));
+        methodDeclaration = methodDeclaration.withReturnTypeExpression(ctx.receiveNode(methodDeclaration.returnTypeExpression, ctx.receiveTree));
+        methodDeclaration = methodDeclaration.annotations.withName(ctx.receiveNode(methodDeclaration.annotations.name, receiveMethodIdentifierWithAnnotations));
+        methodDeclaration = methodDeclaration.padding.withParameters(ctx.receiveNode(methodDeclaration.padding.parameters, receiveContainer));
+        methodDeclaration = methodDeclaration.padding.withThrows(ctx.receiveNode(methodDeclaration.padding.throws, receiveContainer));
+        methodDeclaration = methodDeclaration.withBody(ctx.receiveNode(methodDeclaration.body, ctx.receiveTree));
+        methodDeclaration = methodDeclaration.padding.withDefaultValue(ctx.receiveNode(methodDeclaration.padding.defaultValue, receiveLeftPaddedTree));
+        methodDeclaration = methodDeclaration.withMethodType(ctx.receiveValue(methodDeclaration.methodType, 5));
+        return methodDeclaration;
+    }
+    visitMethodInvocation(methodInvocation, ctx) {
+        methodInvocation = methodInvocation.withId(ctx.receiveValue(methodInvocation.id, 0));
+        methodInvocation = methodInvocation.withPrefix(ctx.receiveNode(methodInvocation.prefix, receiveSpace));
+        methodInvocation = methodInvocation.withMarkers(ctx.receiveNode(methodInvocation.markers, ctx.receiveMarkers));
+        methodInvocation = methodInvocation.padding.withSelect(ctx.receiveNode(methodInvocation.padding.select, receiveRightPaddedTree));
+        methodInvocation = methodInvocation.padding.withTypeParameters(ctx.receiveNode(methodInvocation.padding.typeParameters, receiveContainer));
+        methodInvocation = methodInvocation.withName(ctx.receiveNode(methodInvocation.name, ctx.receiveTree));
+        methodInvocation = methodInvocation.padding.withArguments(ctx.receiveNode(methodInvocation.padding.arguments, receiveContainer));
+        methodInvocation = methodInvocation.withMethodType(ctx.receiveValue(methodInvocation.methodType, 5));
+        return methodInvocation;
+    }
+    visitModifier(modifier, ctx) {
+        modifier = modifier.withId(ctx.receiveValue(modifier.id, 0));
+        modifier = modifier.withPrefix(ctx.receiveNode(modifier.prefix, receiveSpace));
+        modifier = modifier.withMarkers(ctx.receiveNode(modifier.markers, ctx.receiveMarkers));
+        modifier = modifier.withKeyword(ctx.receiveValue(modifier.keyword, 1));
+        modifier = modifier.withType(ctx.receiveValue(modifier.type, 3));
+        modifier = modifier.withAnnotations(ctx.receiveNodes(modifier.annotations, ctx.receiveTree));
+        return modifier;
+    }
+    visitMultiCatch(multiCatch, ctx) {
+        multiCatch = multiCatch.withId(ctx.receiveValue(multiCatch.id, 0));
+        multiCatch = multiCatch.withPrefix(ctx.receiveNode(multiCatch.prefix, receiveSpace));
+        multiCatch = multiCatch.withMarkers(ctx.receiveNode(multiCatch.markers, ctx.receiveMarkers));
+        multiCatch = multiCatch.padding.withAlternatives(ctx.receiveNodes(multiCatch.padding.alternatives, receiveRightPaddedTree));
+        return multiCatch;
+    }
+    visitNewArray(newArray, ctx) {
+        newArray = newArray.withId(ctx.receiveValue(newArray.id, 0));
+        newArray = newArray.withPrefix(ctx.receiveNode(newArray.prefix, receiveSpace));
+        newArray = newArray.withMarkers(ctx.receiveNode(newArray.markers, ctx.receiveMarkers));
+        newArray = newArray.withTypeExpression(ctx.receiveNode(newArray.typeExpression, ctx.receiveTree));
+        newArray = newArray.withDimensions(ctx.receiveNodes(newArray.dimensions, ctx.receiveTree));
+        newArray = newArray.padding.withInitializer(ctx.receiveNode(newArray.padding.initializer, receiveContainer));
+        newArray = newArray.withType(ctx.receiveValue(newArray.type, 5));
+        return newArray;
+    }
+    visitArrayDimension(arrayDimension, ctx) {
+        arrayDimension = arrayDimension.withId(ctx.receiveValue(arrayDimension.id, 0));
+        arrayDimension = arrayDimension.withPrefix(ctx.receiveNode(arrayDimension.prefix, receiveSpace));
+        arrayDimension = arrayDimension.withMarkers(ctx.receiveNode(arrayDimension.markers, ctx.receiveMarkers));
+        arrayDimension = arrayDimension.padding.withIndex(ctx.receiveNode(arrayDimension.padding.index, receiveRightPaddedTree));
+        return arrayDimension;
+    }
+    visitNewClass(newClass, ctx) {
+        newClass = newClass.withId(ctx.receiveValue(newClass.id, 0));
+        newClass = newClass.withPrefix(ctx.receiveNode(newClass.prefix, receiveSpace));
+        newClass = newClass.withMarkers(ctx.receiveNode(newClass.markers, ctx.receiveMarkers));
+        newClass = newClass.padding.withEnclosing(ctx.receiveNode(newClass.padding.enclosing, receiveRightPaddedTree));
+        newClass = newClass.withNew(ctx.receiveNode(newClass.new, receiveSpace));
+        newClass = newClass.withClazz(ctx.receiveNode(newClass.clazz, ctx.receiveTree));
+        newClass = newClass.padding.withArguments(ctx.receiveNode(newClass.padding.arguments, receiveContainer));
+        newClass = newClass.withBody(ctx.receiveNode(newClass.body, ctx.receiveTree));
+        newClass = newClass.withConstructorType(ctx.receiveValue(newClass.constructorType, 5));
+        return newClass;
+    }
+    visitNullableType(nullableType, ctx) {
+        nullableType = nullableType.withId(ctx.receiveValue(nullableType.id, 0));
+        nullableType = nullableType.withPrefix(ctx.receiveNode(nullableType.prefix, receiveSpace));
+        nullableType = nullableType.withMarkers(ctx.receiveNode(nullableType.markers, ctx.receiveMarkers));
+        nullableType = nullableType.withAnnotations(ctx.receiveNodes(nullableType.annotations, ctx.receiveTree));
+        nullableType = nullableType.padding.withTypeTree(ctx.receiveNode(nullableType.padding.typeTree, receiveRightPaddedTree));
+        return nullableType;
+    }
+    visitPackage(_package, ctx) {
+        _package = _package.withId(ctx.receiveValue(_package.id, 0));
+        _package = _package.withPrefix(ctx.receiveNode(_package.prefix, receiveSpace));
+        _package = _package.withMarkers(ctx.receiveNode(_package.markers, ctx.receiveMarkers));
+        _package = _package.withExpression(ctx.receiveNode(_package.expression, ctx.receiveTree));
+        _package = _package.withAnnotations(ctx.receiveNodes(_package.annotations, ctx.receiveTree));
+        return _package;
+    }
+    visitParameterizedType(parameterizedType, ctx) {
+        parameterizedType = parameterizedType.withId(ctx.receiveValue(parameterizedType.id, 0));
+        parameterizedType = parameterizedType.withPrefix(ctx.receiveNode(parameterizedType.prefix, receiveSpace));
+        parameterizedType = parameterizedType.withMarkers(ctx.receiveNode(parameterizedType.markers, ctx.receiveMarkers));
+        parameterizedType = parameterizedType.withClazz(ctx.receiveNode(parameterizedType.clazz, ctx.receiveTree));
+        parameterizedType = parameterizedType.padding.withTypeParameters(ctx.receiveNode(parameterizedType.padding.typeParameters, receiveContainer));
+        parameterizedType = parameterizedType.withType(ctx.receiveValue(parameterizedType.type, 5));
+        return parameterizedType;
+    }
+    visitParentheses(parentheses, ctx) {
+        parentheses = parentheses.withId(ctx.receiveValue(parentheses.id, 0));
+        parentheses = parentheses.withPrefix(ctx.receiveNode(parentheses.prefix, receiveSpace));
+        parentheses = parentheses.withMarkers(ctx.receiveNode(parentheses.markers, ctx.receiveMarkers));
+        parentheses = parentheses.padding.withTree(ctx.receiveNode(parentheses.padding.tree, receiveRightPaddedTree));
+        return parentheses;
+    }
+    visitControlParentheses(controlParentheses, ctx) {
+        controlParentheses = controlParentheses.withId(ctx.receiveValue(controlParentheses.id, 0));
+        controlParentheses = controlParentheses.withPrefix(ctx.receiveNode(controlParentheses.prefix, receiveSpace));
+        controlParentheses = controlParentheses.withMarkers(ctx.receiveNode(controlParentheses.markers, ctx.receiveMarkers));
+        controlParentheses = controlParentheses.padding.withTree(ctx.receiveNode(controlParentheses.padding.tree, receiveRightPaddedTree));
+        return controlParentheses;
+    }
+    visitPrimitive(primitive, ctx) {
+        primitive = primitive.withId(ctx.receiveValue(primitive.id, 0));
+        primitive = primitive.withPrefix(ctx.receiveNode(primitive.prefix, receiveSpace));
+        primitive = primitive.withMarkers(ctx.receiveNode(primitive.markers, ctx.receiveMarkers));
+        primitive = primitive.withType(ctx.receiveValue(primitive.type, 3));
+        return primitive;
+    }
+    visitReturn(_return, ctx) {
+        _return = _return.withId(ctx.receiveValue(_return.id, 0));
+        _return = _return.withPrefix(ctx.receiveNode(_return.prefix, receiveSpace));
+        _return = _return.withMarkers(ctx.receiveNode(_return.markers, ctx.receiveMarkers));
+        _return = _return.withExpression(ctx.receiveNode(_return.expression, ctx.receiveTree));
+        return _return;
+    }
+    visitSwitch(_switch, ctx) {
+        _switch = _switch.withId(ctx.receiveValue(_switch.id, 0));
+        _switch = _switch.withPrefix(ctx.receiveNode(_switch.prefix, receiveSpace));
+        _switch = _switch.withMarkers(ctx.receiveNode(_switch.markers, ctx.receiveMarkers));
+        _switch = _switch.withSelector(ctx.receiveNode(_switch.selector, ctx.receiveTree));
+        _switch = _switch.withCases(ctx.receiveNode(_switch.cases, ctx.receiveTree));
+        return _switch;
+    }
+    visitSwitchExpression(switchExpression, ctx) {
+        switchExpression = switchExpression.withId(ctx.receiveValue(switchExpression.id, 0));
+        switchExpression = switchExpression.withPrefix(ctx.receiveNode(switchExpression.prefix, receiveSpace));
+        switchExpression = switchExpression.withMarkers(ctx.receiveNode(switchExpression.markers, ctx.receiveMarkers));
+        switchExpression = switchExpression.withSelector(ctx.receiveNode(switchExpression.selector, ctx.receiveTree));
+        switchExpression = switchExpression.withCases(ctx.receiveNode(switchExpression.cases, ctx.receiveTree));
+        return switchExpression;
+    }
+    visitSynchronized(synchronized, ctx) {
+        synchronized = synchronized.withId(ctx.receiveValue(synchronized.id, 0));
+        synchronized = synchronized.withPrefix(ctx.receiveNode(synchronized.prefix, receiveSpace));
+        synchronized = synchronized.withMarkers(ctx.receiveNode(synchronized.markers, ctx.receiveMarkers));
+        synchronized = synchronized.withLock(ctx.receiveNode(synchronized.lock, ctx.receiveTree));
+        synchronized = synchronized.withBody(ctx.receiveNode(synchronized.body, ctx.receiveTree));
+        return synchronized;
+    }
+    visitTernary(ternary, ctx) {
+        ternary = ternary.withId(ctx.receiveValue(ternary.id, 0));
+        ternary = ternary.withPrefix(ctx.receiveNode(ternary.prefix, receiveSpace));
+        ternary = ternary.withMarkers(ctx.receiveNode(ternary.markers, ctx.receiveMarkers));
+        ternary = ternary.withCondition(ctx.receiveNode(ternary.condition, ctx.receiveTree));
+        ternary = ternary.padding.withTruePart(ctx.receiveNode(ternary.padding.truePart, receiveLeftPaddedTree));
+        ternary = ternary.padding.withFalsePart(ctx.receiveNode(ternary.padding.falsePart, receiveLeftPaddedTree));
+        ternary = ternary.withType(ctx.receiveValue(ternary.type, 5));
+        return ternary;
+    }
+    visitThrow(_throw, ctx) {
+        _throw = _throw.withId(ctx.receiveValue(_throw.id, 0));
+        _throw = _throw.withPrefix(ctx.receiveNode(_throw.prefix, receiveSpace));
+        _throw = _throw.withMarkers(ctx.receiveNode(_throw.markers, ctx.receiveMarkers));
+        _throw = _throw.withException(ctx.receiveNode(_throw.exception, ctx.receiveTree));
+        return _throw;
+    }
+    visitTry(_try, ctx) {
+        _try = _try.withId(ctx.receiveValue(_try.id, 0));
+        _try = _try.withPrefix(ctx.receiveNode(_try.prefix, receiveSpace));
+        _try = _try.withMarkers(ctx.receiveNode(_try.markers, ctx.receiveMarkers));
+        _try = _try.padding.withResources(ctx.receiveNode(_try.padding.resources, receiveContainer));
+        _try = _try.withBody(ctx.receiveNode(_try.body, ctx.receiveTree));
+        _try = _try.withCatches(ctx.receiveNodes(_try.catches, ctx.receiveTree));
+        _try = _try.padding.withFinally(ctx.receiveNode(_try.padding.finally, receiveLeftPaddedTree));
+        return _try;
+    }
+    visitTryResource(resource, ctx) {
+        resource = resource.withId(ctx.receiveValue(resource.id, 0));
+        resource = resource.withPrefix(ctx.receiveNode(resource.prefix, receiveSpace));
+        resource = resource.withMarkers(ctx.receiveNode(resource.markers, ctx.receiveMarkers));
+        resource = resource.withVariableDeclarations(ctx.receiveNode(resource.variableDeclarations, ctx.receiveTree));
+        resource = resource.withTerminatedWithSemicolon(ctx.receiveValue(resource.terminatedWithSemicolon, 1));
+        return resource;
+    }
+    visitCatch(_catch, ctx) {
+        _catch = _catch.withId(ctx.receiveValue(_catch.id, 0));
+        _catch = _catch.withPrefix(ctx.receiveNode(_catch.prefix, receiveSpace));
+        _catch = _catch.withMarkers(ctx.receiveNode(_catch.markers, ctx.receiveMarkers));
+        _catch = _catch.withParameter(ctx.receiveNode(_catch.parameter, ctx.receiveTree));
+        _catch = _catch.withBody(ctx.receiveNode(_catch.body, ctx.receiveTree));
+        return _catch;
+    }
+    visitTypeCast(typeCast, ctx) {
+        typeCast = typeCast.withId(ctx.receiveValue(typeCast.id, 0));
+        typeCast = typeCast.withPrefix(ctx.receiveNode(typeCast.prefix, receiveSpace));
+        typeCast = typeCast.withMarkers(ctx.receiveNode(typeCast.markers, ctx.receiveMarkers));
+        typeCast = typeCast.withClazz(ctx.receiveNode(typeCast.clazz, ctx.receiveTree));
+        typeCast = typeCast.withExpression(ctx.receiveNode(typeCast.expression, ctx.receiveTree));
+        return typeCast;
+    }
+    visitTypeParameter(typeParameter, ctx) {
+        typeParameter = typeParameter.withId(ctx.receiveValue(typeParameter.id, 0));
+        typeParameter = typeParameter.withPrefix(ctx.receiveNode(typeParameter.prefix, receiveSpace));
+        typeParameter = typeParameter.withMarkers(ctx.receiveNode(typeParameter.markers, ctx.receiveMarkers));
+        typeParameter = typeParameter.withAnnotations(ctx.receiveNodes(typeParameter.annotations, ctx.receiveTree));
+        typeParameter = typeParameter.withModifiers(ctx.receiveNodes(typeParameter.modifiers, ctx.receiveTree));
+        typeParameter = typeParameter.withName(ctx.receiveNode(typeParameter.name, ctx.receiveTree));
+        typeParameter = typeParameter.padding.withBounds(ctx.receiveNode(typeParameter.padding.bounds, receiveContainer));
+        return typeParameter;
+    }
+    visitTypeParameters(typeParameters, ctx) {
+        typeParameters = typeParameters.withId(ctx.receiveValue(typeParameters.id, 0));
+        typeParameters = typeParameters.withPrefix(ctx.receiveNode(typeParameters.prefix, receiveSpace));
+        typeParameters = typeParameters.withMarkers(ctx.receiveNode(typeParameters.markers, ctx.receiveMarkers));
+        typeParameters = typeParameters.withAnnotations(ctx.receiveNodes(typeParameters.annotations, ctx.receiveTree));
+        typeParameters = typeParameters.padding.withTypeParameters(ctx.receiveNodes(typeParameters.padding.typeParameters, receiveRightPaddedTree));
+        return typeParameters;
+    }
+    visitUnary(unary, ctx) {
+        unary = unary.withId(ctx.receiveValue(unary.id, 0));
+        unary = unary.withPrefix(ctx.receiveNode(unary.prefix, receiveSpace));
+        unary = unary.withMarkers(ctx.receiveNode(unary.markers, ctx.receiveMarkers));
+        unary = unary.padding.withOperator(ctx.receiveNode(unary.padding.operator, leftPaddedValueReceiver(3)));
+        unary = unary.withExpression(ctx.receiveNode(unary.expression, ctx.receiveTree));
+        unary = unary.withType(ctx.receiveValue(unary.type, 5));
+        return unary;
+    }
+    visitVariableDeclarations(variableDeclarations, ctx) {
+        variableDeclarations = variableDeclarations.withId(ctx.receiveValue(variableDeclarations.id, 0));
+        variableDeclarations = variableDeclarations.withPrefix(ctx.receiveNode(variableDeclarations.prefix, receiveSpace));
+        variableDeclarations = variableDeclarations.withMarkers(ctx.receiveNode(variableDeclarations.markers, ctx.receiveMarkers));
+        variableDeclarations = variableDeclarations.withLeadingAnnotations(ctx.receiveNodes(variableDeclarations.leadingAnnotations, ctx.receiveTree));
+        variableDeclarations = variableDeclarations.withModifiers(ctx.receiveNodes(variableDeclarations.modifiers, ctx.receiveTree));
+        variableDeclarations = variableDeclarations.withTypeExpression(ctx.receiveNode(variableDeclarations.typeExpression, ctx.receiveTree));
+        variableDeclarations = variableDeclarations.withVarargs(ctx.receiveNode(variableDeclarations.varargs, receiveSpace));
+        variableDeclarations = variableDeclarations.withDimensionsBeforeName(ctx.receiveNodes(variableDeclarations.dimensionsBeforeName, leftPaddedNodeReceiver(tree_1.Space)));
+        variableDeclarations = variableDeclarations.padding.withVariables(ctx.receiveNodes(variableDeclarations.padding.variables, receiveRightPaddedTree));
+        return variableDeclarations;
+    }
+    visitVariable(namedVariable, ctx) {
+        namedVariable = namedVariable.withId(ctx.receiveValue(namedVariable.id, 0));
+        namedVariable = namedVariable.withPrefix(ctx.receiveNode(namedVariable.prefix, receiveSpace));
+        namedVariable = namedVariable.withMarkers(ctx.receiveNode(namedVariable.markers, ctx.receiveMarkers));
+        namedVariable = namedVariable.withName(ctx.receiveNode(namedVariable.name, ctx.receiveTree));
+        namedVariable = namedVariable.withDimensionsAfterName(ctx.receiveNodes(namedVariable.dimensionsAfterName, leftPaddedNodeReceiver(tree_1.Space)));
+        namedVariable = namedVariable.padding.withInitializer(ctx.receiveNode(namedVariable.padding.initializer, receiveLeftPaddedTree));
+        namedVariable = namedVariable.withVariableType(ctx.receiveValue(namedVariable.variableType, 5));
+        return namedVariable;
+    }
+    visitWhileLoop(whileLoop, ctx) {
+        whileLoop = whileLoop.withId(ctx.receiveValue(whileLoop.id, 0));
+        whileLoop = whileLoop.withPrefix(ctx.receiveNode(whileLoop.prefix, receiveSpace));
+        whileLoop = whileLoop.withMarkers(ctx.receiveNode(whileLoop.markers, ctx.receiveMarkers));
+        whileLoop = whileLoop.withCondition(ctx.receiveNode(whileLoop.condition, ctx.receiveTree));
+        whileLoop = whileLoop.padding.withBody(ctx.receiveNode(whileLoop.padding.body, receiveRightPaddedTree));
+        return whileLoop;
+    }
+    visitWildcard(wildcard, ctx) {
+        wildcard = wildcard.withId(ctx.receiveValue(wildcard.id, 0));
+        wildcard = wildcard.withPrefix(ctx.receiveNode(wildcard.prefix, receiveSpace));
+        wildcard = wildcard.withMarkers(ctx.receiveNode(wildcard.markers, ctx.receiveMarkers));
+        wildcard = wildcard.padding.withBound(ctx.receiveNode(wildcard.padding.bound, leftPaddedValueReceiver(3)));
+        wildcard = wildcard.withBoundedType(ctx.receiveNode(wildcard.boundedType, ctx.receiveTree));
+        return wildcard;
+    }
+    visitYield(_yield, ctx) {
+        _yield = _yield.withId(ctx.receiveValue(_yield.id, 0));
+        _yield = _yield.withPrefix(ctx.receiveNode(_yield.prefix, receiveSpace));
+        _yield = _yield.withMarkers(ctx.receiveNode(_yield.markers, ctx.receiveMarkers));
+        _yield = _yield.withImplicit(ctx.receiveValue(_yield.implicit, 1));
+        _yield = _yield.withValue(ctx.receiveNode(_yield.value, ctx.receiveTree));
+        return _yield;
+    }
+    visitUnknown(unknown, ctx) {
+        unknown = unknown.withId(ctx.receiveValue(unknown.id, 0));
+        unknown = unknown.withPrefix(ctx.receiveNode(unknown.prefix, receiveSpace));
+        unknown = unknown.withMarkers(ctx.receiveNode(unknown.markers, ctx.receiveMarkers));
+        unknown = unknown.withSource(ctx.receiveNode(unknown.source, ctx.receiveTree));
+        return unknown;
+    }
+    visitUnknownSource(source, ctx) {
+        source = source.withId(ctx.receiveValue(source.id, 0));
+        source = source.withPrefix(ctx.receiveNode(source.prefix, receiveSpace));
+        source = source.withMarkers(ctx.receiveNode(source.markers, ctx.receiveMarkers));
+        source = source.withText(ctx.receiveValue(source.text, 1));
+        return source;
+    }
+}
+class Factory {
+    create(type, ctx) {
+        if (type === "org.openrewrite.java.tree.J$AnnotatedType") {
+            return new tree_1.AnnotatedType(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Annotation") {
+            return new tree_1.Annotation(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer));
+        }
+        if (type === "org.openrewrite.java.tree.J$ArrayAccess") {
+            return new tree_1.ArrayAccess(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$ArrayType") {
+            return new tree_1.ArrayType(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, leftPaddedNodeReceiver(tree_1.Space)), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Assert") {
+            return new tree_1.Assert(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Assignment") {
+            return new tree_1.Assignment(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$AssignmentOperation") {
+            return new tree_1.AssignmentOperation(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, leftPaddedValueReceiver(3)), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Binary") {
+            return new tree_1.Binary(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, leftPaddedValueReceiver(3)), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Block") {
+            return new tree_1.Block(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, rightPaddedValueReceiver(1)), ctx.receiveNodes(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveSpace));
+        }
+        if (type === "org.openrewrite.java.tree.J$Break") {
+            return new tree_1.Break(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Case") {
+            return new tree_1.Case(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 3), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ClassDeclaration") {
+            return new tree_1.ClassDeclaration(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$ClassDeclaration$Kind") {
+            return new tree_1.ClassDeclaration.Kind(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveValue(null, 3));
+        }
+        if (type === "org.openrewrite.java.tree.J$CompilationUnit") {
+            return new tree_1.CompilationUnit(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 1), ctx.receiveValue(null, 5), ctx.receiveValue(null, 1), ctx.receiveValue(null, 1), ctx.receiveValue(null, 5), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNodes(null, receiveRightPaddedTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, receiveSpace));
+        }
+        if (type === "org.openrewrite.java.tree.J$Continue") {
+            return new tree_1.Continue(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$DoWhileLoop") {
+            return new tree_1.DoWhileLoop(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveLeftPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Empty") {
+            return new tree_1.Empty(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers));
+        }
+        if (type === "org.openrewrite.java.tree.J$EnumValue") {
+            return new tree_1.EnumValue(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$EnumValueSet") {
+            return new tree_1.EnumValueSet(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, receiveRightPaddedTree), ctx.receiveValue(null, 1));
+        }
+        if (type === "org.openrewrite.java.tree.J$FieldAccess") {
+            return new tree_1.FieldAccess(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$ForEachLoop") {
+            return new tree_1.ForEachLoop(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ForEachLoop$Control") {
+            return new tree_1.ForEachLoop.Control(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ForLoop") {
+            return new tree_1.ForLoop(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ForLoop$Control") {
+            return new tree_1.ForLoop.Control(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNodes(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ParenthesizedTypeTree") {
+            return new tree_1.ParenthesizedTypeTree(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Identifier") {
+            return new tree_1.Identifier(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveValue(null, 1), ctx.receiveValue(null, 5), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$If") {
+            return new tree_1.If(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$If$Else") {
+            return new tree_1.If.Else(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Import") {
+            return new tree_1.Import(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, leftPaddedValueReceiver(1)), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$InstanceOf") {
+            return new tree_1.InstanceOf(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$IntersectionType") {
+            return new tree_1.IntersectionType(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveContainer));
+        }
+        if (type === "org.openrewrite.java.tree.J$Label") {
+            return new tree_1.Label(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Lambda") {
+            return new tree_1.Lambda(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Lambda$Parameters") {
+            return new tree_1.Lambda.Parameters(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 1), ctx.receiveNodes(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Literal") {
+            return new tree_1.Literal(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 5), ctx.receiveValue(null, 1), ctx.receiveValues(null, 5), ctx.receiveValue(null, 3));
+        }
+        if (type === "org.openrewrite.java.tree.J$MemberReference") {
+            return new tree_1.MemberReference(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveValue(null, 5), ctx.receiveValue(null, 5), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$MethodDeclaration") {
+            return new tree_1.MethodDeclaration(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveMethodIdentifierWithAnnotations), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$MethodInvocation") {
+            return new tree_1.MethodInvocation(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Modifier") {
+            return new tree_1.Modifier(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 1), ctx.receiveValue(null, 3), ctx.receiveNodes(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$MultiCatch") {
+            return new tree_1.MultiCatch(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$NewArray") {
+            return new tree_1.NewArray(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$ArrayDimension") {
+            return new tree_1.ArrayDimension(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$NewClass") {
+            return new tree_1.NewClass(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$NullableType") {
+            return new tree_1.NullableType(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Package") {
+            return new tree_1.Package(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ParameterizedType") {
+            return new tree_1.ParameterizedType(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Parentheses") {
+            return new tree_1.Parentheses(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$ControlParentheses") {
+            return new tree_1.ControlParentheses(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Primitive") {
+            return new tree_1.Primitive(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 3));
+        }
+        if (type === "org.openrewrite.java.tree.J$Return") {
+            return new tree_1.Return(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Switch") {
+            return new tree_1.Switch(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$SwitchExpression") {
+            return new tree_1.SwitchExpression(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Synchronized") {
+            return new tree_1.Synchronized(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Ternary") {
+            return new tree_1.Ternary(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$Throw") {
+            return new tree_1.Throw(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Try") {
+            return new tree_1.Try(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, receiveContainer), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, receiveLeftPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Try$Resource") {
+            return new tree_1.Try.Resource(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 1));
+        }
+        if (type === "org.openrewrite.java.tree.J$Try$Catch") {
+            return new tree_1.Try.Catch(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$TypeCast") {
+            return new tree_1.TypeCast(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$TypeParameter") {
+            return new tree_1.TypeParameter(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveContainer));
+        }
+        if (type === "org.openrewrite.java.tree.J$TypeParameters") {
+            return new tree_1.TypeParameters(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNodes(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Unary") {
+            return new tree_1.Unary(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, leftPaddedValueReceiver(3)), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$VariableDeclarations") {
+            return new tree_1.VariableDeclarations(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveSpace), ctx.receiveNodes(null, leftPaddedNodeReceiver(tree_1.Space)), ctx.receiveNodes(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$VariableDeclarations$NamedVariable") {
+            return new tree_1.VariableDeclarations.NamedVariable(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNodes(null, leftPaddedNodeReceiver(tree_1.Space)), ctx.receiveNode(null, receiveLeftPaddedTree), ctx.receiveValue(null, 5));
+        }
+        if (type === "org.openrewrite.java.tree.J$WhileLoop") {
+            return new tree_1.WhileLoop(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNode(null, receiveRightPaddedTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Wildcard") {
+            return new tree_1.Wildcard(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, leftPaddedValueReceiver(3)), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Yield") {
+            return new tree_1.Yield(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 1), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Unknown") {
+            return new tree_1.Unknown(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveNode(null, ctx.receiveTree));
+        }
+        if (type === "org.openrewrite.java.tree.J$Unknown$Source") {
+            return new tree_1.Unknown.Source(ctx.receiveValue(null, 0), ctx.receiveNode(null, receiveSpace), ctx.receiveNode(null, ctx.receiveMarkers), ctx.receiveValue(null, 1));
+        }
+        throw new Error("No factory method for type: " + type);
+    }
+}
+function receiveMethodIdentifierWithAnnotations(before, type, ctx) {
+    if (before !== null) {
+        before = before.withIdentifier(ctx.receiveNode(before.identifier, ctx.receiveTree));
+        before = before.withAnnotations(ctx.receiveNodes(before.annotations, ctx.receiveTree));
+    }
+    else {
+        before = new Java.MethodDeclaration.IdentifierWithAnnotations(ctx.receiveNode(null, ctx.receiveTree), ctx.receiveNodes(null, ctx.receiveTree));
+    }
+    return before;
+}
+function receiveContainer(container, type, ctx) {
+    return extensions.receiveContainer(container, type, ctx);
+}
+function leftPaddedValueReceiver(type) {
+    return extensions.leftPaddedValueReceiver(type);
+}
+function leftPaddedNodeReceiver(type) {
+    return extensions.leftPaddedNodeReceiver(type);
+}
+function receiveLeftPaddedTree(leftPadded, type, ctx) {
+    return extensions.receiveLeftPaddedTree(leftPadded, type, ctx);
+}
+function rightPaddedValueReceiver(type) {
+    return extensions.rightPaddedValueReceiver(type);
+}
+function rightPaddedNodeReceiver(type) {
+    return extensions.rightPaddedNodeReceiver(type);
+}
+function receiveRightPaddedTree(rightPadded, type, ctx) {
+    return extensions.receiveRightPaddedTree(rightPadded, type, ctx);
+}
+function receiveSpace(space, type, ctx) {
+    return extensions.receiveSpace(space, type, ctx);
+}
+//# sourceMappingURL=receiver.js.map