@openrewrite/rewrite 0.18.4 → 0.18.7

package/dist/src/javascript/remote/sender.js

@@ -0,0 +1,898 @@
+"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.JavaScriptSender = void 0;
+const extensions = __importStar(require("./remote_extensions"));
+const core_1 = require("../../core");
+const __1 = require("..");
+class JavaScriptSender {
+    send(after, before, ctx) {
+        let visitor = new Visitor();
+        visitor.visit(after, ctx.fork(visitor, before));
+    }
+}
+exports.JavaScriptSender = JavaScriptSender;
+class Visitor extends __1.JavaScriptVisitor {
+    visit(tree, ctx) {
+        this.cursor = new core_1.Cursor(this.cursor, tree);
+        ctx.sendNode(tree, x => x, ctx.sendTree);
+        this.cursor = this.cursor.parent;
+        return tree;
+    }
+    visitJsCompilationUnit(compilationUnit, ctx) {
+        ctx.sendValue(compilationUnit, v => v.id, 0);
+        ctx.sendNode(compilationUnit, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(compilationUnit, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(compilationUnit, v => v.sourcePath, 1);
+        ctx.sendTypedValue(compilationUnit, v => v.fileAttributes, 5);
+        ctx.sendValue(compilationUnit, v => v.charsetName, 1);
+        ctx.sendValue(compilationUnit, v => v.charsetBomMarked, 1);
+        ctx.sendTypedValue(compilationUnit, v => v.checksum, 5);
+        ctx.sendNodes(compilationUnit, v => v.padding.imports, Visitor.sendRightPadded(4), t => t.element.id);
+        ctx.sendNodes(compilationUnit, v => v.padding.statements, Visitor.sendRightPadded(4), t => t.element.id);
+        ctx.sendNode(compilationUnit, v => v.eof, Visitor.sendSpace);
+        return compilationUnit;
+    }
+    visitAlias(alias, ctx) {
+        ctx.sendValue(alias, v => v.id, 0);
+        ctx.sendNode(alias, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(alias, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(alias, v => v.padding.propertyName, Visitor.sendRightPadded(4));
+        ctx.sendNode(alias, v => v.alias, ctx.sendTree);
+        return alias;
+    }
+    visitArrowFunction(arrowFunction, ctx) {
+        ctx.sendValue(arrowFunction, v => v.id, 0);
+        ctx.sendNode(arrowFunction, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(arrowFunction, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(arrowFunction, v => v.leadingAnnotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(arrowFunction, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(arrowFunction, v => v.parameters, ctx.sendTree);
+        ctx.sendNode(arrowFunction, v => v.returnTypeExpression, ctx.sendTree);
+        ctx.sendNode(arrowFunction, v => v.arrow, Visitor.sendSpace);
+        ctx.sendNode(arrowFunction, v => v.body, ctx.sendTree);
+        ctx.sendTypedValue(arrowFunction, v => v.type, 5);
+        return arrowFunction;
+    }
+    visitAwait(await, ctx) {
+        ctx.sendValue(await, v => v.id, 0);
+        ctx.sendNode(await, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(await, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(await, v => v.expression, ctx.sendTree);
+        ctx.sendTypedValue(await, v => v.type, 5);
+        return await;
+    }
+    visitDefaultType(defaultType, ctx) {
+        ctx.sendValue(defaultType, v => v.id, 0);
+        ctx.sendNode(defaultType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(defaultType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(defaultType, v => v.left, ctx.sendTree);
+        ctx.sendNode(defaultType, v => v.beforeEquals, Visitor.sendSpace);
+        ctx.sendNode(defaultType, v => v.right, ctx.sendTree);
+        ctx.sendTypedValue(defaultType, v => v.type, 5);
+        return defaultType;
+    }
+    visitDelete(_delete, ctx) {
+        ctx.sendValue(_delete, v => v.id, 0);
+        ctx.sendNode(_delete, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_delete, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_delete, v => v.expression, ctx.sendTree);
+        ctx.sendTypedValue(_delete, v => v.type, 5);
+        return _delete;
+    }
+    visitExport(_export, ctx) {
+        ctx.sendValue(_export, v => v.id, 0);
+        ctx.sendNode(_export, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_export, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_export, v => v.padding.exports, Visitor.sendContainer(4));
+        ctx.sendNode(_export, v => v.from, Visitor.sendSpace);
+        ctx.sendNode(_export, v => v.target, ctx.sendTree);
+        ctx.sendNode(_export, v => v.padding.initializer, Visitor.sendLeftPadded(4));
+        return _export;
+    }
+    visitExpressionStatement(expressionStatement, ctx) {
+        ctx.sendValue(expressionStatement, v => v.id, 0);
+        ctx.sendNode(expressionStatement, v => v.expression, ctx.sendTree);
+        return expressionStatement;
+    }
+    visitFunctionType(functionType, ctx) {
+        ctx.sendValue(functionType, v => v.id, 0);
+        ctx.sendNode(functionType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(functionType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(functionType, v => v.padding.parameters, Visitor.sendContainer(4));
+        ctx.sendNode(functionType, v => v.arrow, Visitor.sendSpace);
+        ctx.sendNode(functionType, v => v.returnType, ctx.sendTree);
+        ctx.sendTypedValue(functionType, v => v.type, 5);
+        return functionType;
+    }
+    visitJsImport(jsImport, ctx) {
+        ctx.sendValue(jsImport, v => v.id, 0);
+        ctx.sendNode(jsImport, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(jsImport, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(jsImport, v => v.padding.name, Visitor.sendRightPadded(4));
+        ctx.sendNode(jsImport, v => v.padding.imports, Visitor.sendContainer(4));
+        ctx.sendNode(jsImport, v => v.from, Visitor.sendSpace);
+        ctx.sendNode(jsImport, v => v.target, ctx.sendTree);
+        ctx.sendNode(jsImport, v => v.padding.initializer, Visitor.sendLeftPadded(4));
+        return jsImport;
+    }
+    visitJsBinary(jsBinary, ctx) {
+        ctx.sendValue(jsBinary, v => v.id, 0);
+        ctx.sendNode(jsBinary, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(jsBinary, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(jsBinary, v => v.left, ctx.sendTree);
+        ctx.sendNode(jsBinary, v => v.padding.operator, Visitor.sendLeftPadded(3));
+        ctx.sendNode(jsBinary, v => v.right, ctx.sendTree);
+        ctx.sendTypedValue(jsBinary, v => v.type, 5);
+        return jsBinary;
+    }
+    visitObjectBindingDeclarations(objectBindingDeclarations, ctx) {
+        ctx.sendValue(objectBindingDeclarations, v => v.id, 0);
+        ctx.sendNode(objectBindingDeclarations, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(objectBindingDeclarations, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(objectBindingDeclarations, v => v.leadingAnnotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(objectBindingDeclarations, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(objectBindingDeclarations, v => v.typeExpression, ctx.sendTree);
+        ctx.sendNode(objectBindingDeclarations, v => v.padding.bindings, Visitor.sendContainer(4));
+        ctx.sendNode(objectBindingDeclarations, v => v.padding.initializer, Visitor.sendLeftPadded(4));
+        return objectBindingDeclarations;
+    }
+    visitBinding(binding, ctx) {
+        ctx.sendValue(binding, v => v.id, 0);
+        ctx.sendNode(binding, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(binding, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(binding, v => v.padding.propertyName, Visitor.sendRightPadded(4));
+        ctx.sendNode(binding, v => v.name, ctx.sendTree);
+        ctx.sendNodes(binding, v => v.dimensionsAfterName, Visitor.sendLeftPadded(5), t => t);
+        ctx.sendNode(binding, v => v.afterVararg, Visitor.sendSpace);
+        ctx.sendNode(binding, v => v.padding.initializer, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(binding, v => v.variableType, 5);
+        return binding;
+    }
+    visitPropertyAssignment(propertyAssignment, ctx) {
+        ctx.sendValue(propertyAssignment, v => v.id, 0);
+        ctx.sendNode(propertyAssignment, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(propertyAssignment, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(propertyAssignment, v => v.padding.name, Visitor.sendRightPadded(4));
+        ctx.sendNode(propertyAssignment, v => v.initializer, ctx.sendTree);
+        return propertyAssignment;
+    }
+    visitScopedVariableDeclarations(scopedVariableDeclarations, ctx) {
+        ctx.sendValue(scopedVariableDeclarations, v => v.id, 0);
+        ctx.sendNode(scopedVariableDeclarations, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(scopedVariableDeclarations, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(scopedVariableDeclarations, v => v.scope, 3);
+        ctx.sendNodes(scopedVariableDeclarations, v => v.padding.variables, Visitor.sendRightPadded(4), t => t.element.id);
+        return scopedVariableDeclarations;
+    }
+    visitStatementExpression(statementExpression, ctx) {
+        ctx.sendValue(statementExpression, v => v.id, 0);
+        ctx.sendNode(statementExpression, v => v.statement, ctx.sendTree);
+        return statementExpression;
+    }
+    visitTemplateExpression(templateExpression, ctx) {
+        ctx.sendValue(templateExpression, v => v.id, 0);
+        ctx.sendNode(templateExpression, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(templateExpression, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(templateExpression, v => v.delimiter, 1);
+        ctx.sendNode(templateExpression, v => v.padding.tag, Visitor.sendRightPadded(4));
+        ctx.sendNodes(templateExpression, v => v.strings, ctx.sendTree, t => t.id);
+        ctx.sendTypedValue(templateExpression, v => v.type, 5);
+        return templateExpression;
+    }
+    visitTemplateExpressionValue(value, ctx) {
+        ctx.sendValue(value, v => v.id, 0);
+        ctx.sendNode(value, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(value, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(value, v => v.tree, ctx.sendTree);
+        ctx.sendNode(value, v => v.after, Visitor.sendSpace);
+        ctx.sendValue(value, v => v.enclosedInBraces, 1);
+        return value;
+    }
+    visitTuple(tuple, ctx) {
+        ctx.sendValue(tuple, v => v.id, 0);
+        ctx.sendNode(tuple, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(tuple, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(tuple, v => v.padding.elements, Visitor.sendContainer(4));
+        ctx.sendTypedValue(tuple, v => v.type, 5);
+        return tuple;
+    }
+    visitTypeDeclaration(typeDeclaration, ctx) {
+        ctx.sendValue(typeDeclaration, v => v.id, 0);
+        ctx.sendNode(typeDeclaration, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(typeDeclaration, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(typeDeclaration, v => v.leadingAnnotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(typeDeclaration, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(typeDeclaration, v => v.name, ctx.sendTree);
+        ctx.sendNode(typeDeclaration, v => v.typeParameters, ctx.sendTree);
+        ctx.sendNode(typeDeclaration, v => v.padding.initializer, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(typeDeclaration, v => v.type, 5);
+        return typeDeclaration;
+    }
+    visitTypeOf(typeOf, ctx) {
+        ctx.sendValue(typeOf, v => v.id, 0);
+        ctx.sendNode(typeOf, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(typeOf, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(typeOf, v => v.expression, ctx.sendTree);
+        ctx.sendTypedValue(typeOf, v => v.type, 5);
+        return typeOf;
+    }
+    visitTypeOperator(typeOperator, ctx) {
+        ctx.sendValue(typeOperator, v => v.id, 0);
+        ctx.sendNode(typeOperator, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(typeOperator, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(typeOperator, v => v.operator, 3);
+        ctx.sendNode(typeOperator, v => v.padding.expression, Visitor.sendLeftPadded(4));
+        return typeOperator;
+    }
+    visitJsUnary(unary, ctx) {
+        ctx.sendValue(unary, v => v.id, 0);
+        ctx.sendNode(unary, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(unary, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(unary, v => v.padding.operator, Visitor.sendLeftPadded(3));
+        ctx.sendNode(unary, v => v.expression, ctx.sendTree);
+        ctx.sendTypedValue(unary, v => v.type, 5);
+        return unary;
+    }
+    visitUnion(union, ctx) {
+        ctx.sendValue(union, v => v.id, 0);
+        ctx.sendNode(union, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(union, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(union, v => v.padding.types, Visitor.sendRightPadded(4), t => t.element.id);
+        ctx.sendTypedValue(union, v => v.type, 5);
+        return union;
+    }
+    visitVoid(_void, ctx) {
+        ctx.sendValue(_void, v => v.id, 0);
+        ctx.sendNode(_void, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_void, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_void, v => v.expression, ctx.sendTree);
+        return _void;
+    }
+    visitJsYield(_yield, ctx) {
+        ctx.sendValue(_yield, v => v.id, 0);
+        ctx.sendNode(_yield, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_yield, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(_yield, v => v.delegated, 1);
+        ctx.sendNode(_yield, v => v.expression, ctx.sendTree);
+        ctx.sendTypedValue(_yield, v => v.type, 5);
+        return _yield;
+    }
+    visitAnnotatedType(annotatedType, ctx) {
+        ctx.sendValue(annotatedType, v => v.id, 0);
+        ctx.sendNode(annotatedType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(annotatedType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(annotatedType, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNode(annotatedType, v => v.typeExpression, ctx.sendTree);
+        return annotatedType;
+    }
+    visitAnnotation(annotation, ctx) {
+        ctx.sendValue(annotation, v => v.id, 0);
+        ctx.sendNode(annotation, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(annotation, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(annotation, v => v.annotationType, ctx.sendTree);
+        ctx.sendNode(annotation, v => v.padding.arguments, Visitor.sendContainer(4));
+        return annotation;
+    }
+    visitArrayAccess(arrayAccess, ctx) {
+        ctx.sendValue(arrayAccess, v => v.id, 0);
+        ctx.sendNode(arrayAccess, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(arrayAccess, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(arrayAccess, v => v.indexed, ctx.sendTree);
+        ctx.sendNode(arrayAccess, v => v.dimension, ctx.sendTree);
+        ctx.sendTypedValue(arrayAccess, v => v.type, 5);
+        return arrayAccess;
+    }
+    visitArrayType(arrayType, ctx) {
+        ctx.sendValue(arrayType, v => v.id, 0);
+        ctx.sendNode(arrayType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(arrayType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(arrayType, v => v.elementType, ctx.sendTree);
+        ctx.sendNodes(arrayType, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNode(arrayType, v => v.dimension, Visitor.sendLeftPadded(5));
+        ctx.sendTypedValue(arrayType, v => v.type, 5);
+        return arrayType;
+    }
+    visitAssert(assert, ctx) {
+        ctx.sendValue(assert, v => v.id, 0);
+        ctx.sendNode(assert, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(assert, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(assert, v => v.condition, ctx.sendTree);
+        ctx.sendNode(assert, v => v.detail, Visitor.sendLeftPadded(4));
+        return assert;
+    }
+    visitAssignment(assignment, ctx) {
+        ctx.sendValue(assignment, v => v.id, 0);
+        ctx.sendNode(assignment, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(assignment, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(assignment, v => v.variable, ctx.sendTree);
+        ctx.sendNode(assignment, v => v.padding.assignment, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(assignment, v => v.type, 5);
+        return assignment;
+    }
+    visitAssignmentOperation(assignmentOperation, ctx) {
+        ctx.sendValue(assignmentOperation, v => v.id, 0);
+        ctx.sendNode(assignmentOperation, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(assignmentOperation, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(assignmentOperation, v => v.variable, ctx.sendTree);
+        ctx.sendNode(assignmentOperation, v => v.padding.operator, Visitor.sendLeftPadded(3));
+        ctx.sendNode(assignmentOperation, v => v.assignment, ctx.sendTree);
+        ctx.sendTypedValue(assignmentOperation, v => v.type, 5);
+        return assignmentOperation;
+    }
+    visitBinary(binary, ctx) {
+        ctx.sendValue(binary, v => v.id, 0);
+        ctx.sendNode(binary, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(binary, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(binary, v => v.left, ctx.sendTree);
+        ctx.sendNode(binary, v => v.padding.operator, Visitor.sendLeftPadded(3));
+        ctx.sendNode(binary, v => v.right, ctx.sendTree);
+        ctx.sendTypedValue(binary, v => v.type, 5);
+        return binary;
+    }
+    visitBlock(block, ctx) {
+        ctx.sendValue(block, v => v.id, 0);
+        ctx.sendNode(block, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(block, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(block, v => v.padding.static, Visitor.sendRightPadded(1));
+        ctx.sendNodes(block, v => v.padding.statements, Visitor.sendRightPadded(4), t => t.element.id);
+        ctx.sendNode(block, v => v.end, Visitor.sendSpace);
+        return block;
+    }
+    visitBreak(_break, ctx) {
+        ctx.sendValue(_break, v => v.id, 0);
+        ctx.sendNode(_break, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_break, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_break, v => v.label, ctx.sendTree);
+        return _break;
+    }
+    visitCase(_case, ctx) {
+        ctx.sendValue(_case, v => v.id, 0);
+        ctx.sendNode(_case, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_case, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(_case, v => v.type, 3);
+        ctx.sendNode(_case, v => v.padding.expressions, Visitor.sendContainer(4));
+        ctx.sendNode(_case, v => v.padding.statements, Visitor.sendContainer(4));
+        ctx.sendNode(_case, v => v.padding.body, Visitor.sendRightPadded(4));
+        return _case;
+    }
+    visitClassDeclaration(classDeclaration, ctx) {
+        ctx.sendValue(classDeclaration, v => v.id, 0);
+        ctx.sendNode(classDeclaration, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(classDeclaration, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(classDeclaration, v => v.leadingAnnotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(classDeclaration, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(classDeclaration, v => v.padding.kind, ctx.sendTree);
+        ctx.sendNode(classDeclaration, v => v.name, ctx.sendTree);
+        ctx.sendNode(classDeclaration, v => v.padding.typeParameters, Visitor.sendContainer(4));
+        ctx.sendNode(classDeclaration, v => v.padding.primaryConstructor, Visitor.sendContainer(4));
+        ctx.sendNode(classDeclaration, v => v.padding.extends, Visitor.sendLeftPadded(4));
+        ctx.sendNode(classDeclaration, v => v.padding.implements, Visitor.sendContainer(4));
+        ctx.sendNode(classDeclaration, v => v.padding.permits, Visitor.sendContainer(4));
+        ctx.sendNode(classDeclaration, v => v.body, ctx.sendTree);
+        ctx.sendTypedValue(classDeclaration, v => v.type, 5);
+        return classDeclaration;
+    }
+    visitClassDeclarationKind(kind, ctx) {
+        ctx.sendValue(kind, v => v.id, 0);
+        ctx.sendNode(kind, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(kind, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(kind, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendValue(kind, v => v.type, 3);
+        return kind;
+    }
+    visitContinue(_continue, ctx) {
+        ctx.sendValue(_continue, v => v.id, 0);
+        ctx.sendNode(_continue, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_continue, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_continue, v => v.label, ctx.sendTree);
+        return _continue;
+    }
+    visitDoWhileLoop(doWhileLoop, ctx) {
+        ctx.sendValue(doWhileLoop, v => v.id, 0);
+        ctx.sendNode(doWhileLoop, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(doWhileLoop, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(doWhileLoop, v => v.padding.body, Visitor.sendRightPadded(4));
+        ctx.sendNode(doWhileLoop, v => v.padding.whileCondition, Visitor.sendLeftPadded(4));
+        return doWhileLoop;
+    }
+    visitEmpty(empty, ctx) {
+        ctx.sendValue(empty, v => v.id, 0);
+        ctx.sendNode(empty, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(empty, v => v.markers, ctx.sendMarkers);
+        return empty;
+    }
+    visitEnumValue(enumValue, ctx) {
+        ctx.sendValue(enumValue, v => v.id, 0);
+        ctx.sendNode(enumValue, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(enumValue, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(enumValue, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNode(enumValue, v => v.name, ctx.sendTree);
+        ctx.sendNode(enumValue, v => v.initializer, ctx.sendTree);
+        return enumValue;
+    }
+    visitEnumValueSet(enumValueSet, ctx) {
+        ctx.sendValue(enumValueSet, v => v.id, 0);
+        ctx.sendNode(enumValueSet, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(enumValueSet, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(enumValueSet, v => v.padding.enums, Visitor.sendRightPadded(4), t => t.element.id);
+        ctx.sendValue(enumValueSet, v => v.terminatedWithSemicolon, 1);
+        return enumValueSet;
+    }
+    visitFieldAccess(fieldAccess, ctx) {
+        ctx.sendValue(fieldAccess, v => v.id, 0);
+        ctx.sendNode(fieldAccess, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(fieldAccess, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(fieldAccess, v => v.target, ctx.sendTree);
+        ctx.sendNode(fieldAccess, v => v.padding.name, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(fieldAccess, v => v.type, 5);
+        return fieldAccess;
+    }
+    visitForEachLoop(forEachLoop, ctx) {
+        ctx.sendValue(forEachLoop, v => v.id, 0);
+        ctx.sendNode(forEachLoop, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(forEachLoop, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(forEachLoop, v => v.control, ctx.sendTree);
+        ctx.sendNode(forEachLoop, v => v.padding.body, Visitor.sendRightPadded(4));
+        return forEachLoop;
+    }
+    visitForEachControl(control, ctx) {
+        ctx.sendValue(control, v => v.id, 0);
+        ctx.sendNode(control, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(control, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(control, v => v.padding.variable, Visitor.sendRightPadded(4));
+        ctx.sendNode(control, v => v.padding.iterable, Visitor.sendRightPadded(4));
+        return control;
+    }
+    visitForLoop(forLoop, ctx) {
+        ctx.sendValue(forLoop, v => v.id, 0);
+        ctx.sendNode(forLoop, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(forLoop, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(forLoop, v => v.control, ctx.sendTree);
+        ctx.sendNode(forLoop, v => v.padding.body, Visitor.sendRightPadded(4));
+        return forLoop;
+    }
+    visitForControl(control, ctx) {
+        ctx.sendValue(control, v => v.id, 0);
+        ctx.sendNode(control, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(control, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(control, v => v.padding.init, Visitor.sendRightPadded(4), t => t.element.id);
+        ctx.sendNode(control, v => v.padding.condition, Visitor.sendRightPadded(4));
+        ctx.sendNodes(control, v => v.padding.update, Visitor.sendRightPadded(4), t => t.element.id);
+        return control;
+    }
+    visitParenthesizedTypeTree(parenthesizedTypeTree, ctx) {
+        ctx.sendValue(parenthesizedTypeTree, v => v.id, 0);
+        ctx.sendNode(parenthesizedTypeTree, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(parenthesizedTypeTree, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(parenthesizedTypeTree, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNode(parenthesizedTypeTree, v => v.parenthesizedType, ctx.sendTree);
+        return parenthesizedTypeTree;
+    }
+    visitIdentifier(identifier, ctx) {
+        ctx.sendValue(identifier, v => v.id, 0);
+        ctx.sendNode(identifier, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(identifier, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(identifier, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendValue(identifier, v => v.simpleName, 1);
+        ctx.sendTypedValue(identifier, v => v.type, 5);
+        ctx.sendTypedValue(identifier, v => v.fieldType, 5);
+        return identifier;
+    }
+    visitIf(_if, ctx) {
+        ctx.sendValue(_if, v => v.id, 0);
+        ctx.sendNode(_if, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_if, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_if, v => v.ifCondition, ctx.sendTree);
+        ctx.sendNode(_if, v => v.padding.thenPart, Visitor.sendRightPadded(4));
+        ctx.sendNode(_if, v => v.elsePart, ctx.sendTree);
+        return _if;
+    }
+    visitElse(_else, ctx) {
+        ctx.sendValue(_else, v => v.id, 0);
+        ctx.sendNode(_else, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_else, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_else, v => v.padding.body, Visitor.sendRightPadded(4));
+        return _else;
+    }
+    visitImport(_import, ctx) {
+        ctx.sendValue(_import, v => v.id, 0);
+        ctx.sendNode(_import, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_import, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_import, v => v.padding.static, Visitor.sendLeftPadded(1));
+        ctx.sendNode(_import, v => v.qualid, ctx.sendTree);
+        ctx.sendNode(_import, v => v.padding.alias, Visitor.sendLeftPadded(4));
+        return _import;
+    }
+    visitInstanceOf(instanceOf, ctx) {
+        ctx.sendValue(instanceOf, v => v.id, 0);
+        ctx.sendNode(instanceOf, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(instanceOf, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(instanceOf, v => v.padding.expression, Visitor.sendRightPadded(4));
+        ctx.sendNode(instanceOf, v => v.clazz, ctx.sendTree);
+        ctx.sendNode(instanceOf, v => v.pattern, ctx.sendTree);
+        ctx.sendTypedValue(instanceOf, v => v.type, 5);
+        return instanceOf;
+    }
+    visitIntersectionType(intersectionType, ctx) {
+        ctx.sendValue(intersectionType, v => v.id, 0);
+        ctx.sendNode(intersectionType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(intersectionType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(intersectionType, v => v.padding.bounds, Visitor.sendContainer(4));
+        return intersectionType;
+    }
+    visitLabel(label, ctx) {
+        ctx.sendValue(label, v => v.id, 0);
+        ctx.sendNode(label, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(label, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(label, v => v.padding.label, Visitor.sendRightPadded(4));
+        ctx.sendNode(label, v => v.statement, ctx.sendTree);
+        return label;
+    }
+    visitLambda(lambda, ctx) {
+        ctx.sendValue(lambda, v => v.id, 0);
+        ctx.sendNode(lambda, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(lambda, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(lambda, v => v.parameters, ctx.sendTree);
+        ctx.sendNode(lambda, v => v.arrow, Visitor.sendSpace);
+        ctx.sendNode(lambda, v => v.body, ctx.sendTree);
+        ctx.sendTypedValue(lambda, v => v.type, 5);
+        return lambda;
+    }
+    visitLambdaParameters(parameters, ctx) {
+        ctx.sendValue(parameters, v => v.id, 0);
+        ctx.sendNode(parameters, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(parameters, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(parameters, v => v.parenthesized, 1);
+        ctx.sendNodes(parameters, v => v.padding.parameters, Visitor.sendRightPadded(4), t => t.element.id);
+        return parameters;
+    }
+    visitLiteral(literal, ctx) {
+        ctx.sendValue(literal, v => v.id, 0);
+        ctx.sendNode(literal, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(literal, v => v.markers, ctx.sendMarkers);
+        ctx.sendTypedValue(literal, v => v.value, 5);
+        ctx.sendValue(literal, v => v.valueSource, 1);
+        ctx.sendValues(literal, v => v.unicodeEscapes, x => x, 5);
+        ctx.sendValue(literal, v => v.type, 3);
+        return literal;
+    }
+    visitMemberReference(memberReference, ctx) {
+        ctx.sendValue(memberReference, v => v.id, 0);
+        ctx.sendNode(memberReference, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(memberReference, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(memberReference, v => v.padding.containing, Visitor.sendRightPadded(4));
+        ctx.sendNode(memberReference, v => v.padding.typeParameters, Visitor.sendContainer(4));
+        ctx.sendNode(memberReference, v => v.padding.reference, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(memberReference, v => v.type, 5);
+        ctx.sendTypedValue(memberReference, v => v.methodType, 5);
+        ctx.sendTypedValue(memberReference, v => v.variableType, 5);
+        return memberReference;
+    }
+    visitMethodDeclaration(methodDeclaration, ctx) {
+        ctx.sendValue(methodDeclaration, v => v.id, 0);
+        ctx.sendNode(methodDeclaration, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(methodDeclaration, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(methodDeclaration, v => v.leadingAnnotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(methodDeclaration, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(methodDeclaration, v => v.annotations.typeParameters, ctx.sendTree);
+        ctx.sendNode(methodDeclaration, v => v.returnTypeExpression, ctx.sendTree);
+        ctx.sendNode(methodDeclaration, v => v.annotations.name, this.sendMethodIdentifierWithAnnotations);
+        ctx.sendNode(methodDeclaration, v => v.padding.parameters, Visitor.sendContainer(4));
+        ctx.sendNode(methodDeclaration, v => v.padding.throws, Visitor.sendContainer(4));
+        ctx.sendNode(methodDeclaration, v => v.body, ctx.sendTree);
+        ctx.sendNode(methodDeclaration, v => v.padding.defaultValue, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(methodDeclaration, v => v.methodType, 5);
+        return methodDeclaration;
+    }
+    sendMethodIdentifierWithAnnotations(identifierWithAnnotations, ctx) {
+        ctx.sendNode(identifierWithAnnotations, v => v.identifier, ctx.sendTree);
+        ctx.sendNodes(identifierWithAnnotations, v => v.annotations, ctx.sendTree, v => v.id);
+    }
+    visitMethodInvocation(methodInvocation, ctx) {
+        ctx.sendValue(methodInvocation, v => v.id, 0);
+        ctx.sendNode(methodInvocation, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(methodInvocation, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(methodInvocation, v => v.padding.select, Visitor.sendRightPadded(4));
+        ctx.sendNode(methodInvocation, v => v.padding.typeParameters, Visitor.sendContainer(4));
+        ctx.sendNode(methodInvocation, v => v.name, ctx.sendTree);
+        ctx.sendNode(methodInvocation, v => v.padding.arguments, Visitor.sendContainer(4));
+        ctx.sendTypedValue(methodInvocation, v => v.methodType, 5);
+        return methodInvocation;
+    }
+    visitModifier(modifier, ctx) {
+        ctx.sendValue(modifier, v => v.id, 0);
+        ctx.sendNode(modifier, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(modifier, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(modifier, v => v.keyword, 1);
+        ctx.sendValue(modifier, v => v.type, 3);
+        ctx.sendNodes(modifier, v => v.annotations, ctx.sendTree, t => t.id);
+        return modifier;
+    }
+    visitMultiCatch(multiCatch, ctx) {
+        ctx.sendValue(multiCatch, v => v.id, 0);
+        ctx.sendNode(multiCatch, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(multiCatch, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(multiCatch, v => v.padding.alternatives, Visitor.sendRightPadded(4), t => t.element.id);
+        return multiCatch;
+    }
+    visitNewArray(newArray, ctx) {
+        ctx.sendValue(newArray, v => v.id, 0);
+        ctx.sendNode(newArray, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(newArray, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(newArray, v => v.typeExpression, ctx.sendTree);
+        ctx.sendNodes(newArray, v => v.dimensions, ctx.sendTree, t => t.id);
+        ctx.sendNode(newArray, v => v.padding.initializer, Visitor.sendContainer(4));
+        ctx.sendTypedValue(newArray, v => v.type, 5);
+        return newArray;
+    }
+    visitArrayDimension(arrayDimension, ctx) {
+        ctx.sendValue(arrayDimension, v => v.id, 0);
+        ctx.sendNode(arrayDimension, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(arrayDimension, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(arrayDimension, v => v.padding.index, Visitor.sendRightPadded(4));
+        return arrayDimension;
+    }
+    visitNewClass(newClass, ctx) {
+        ctx.sendValue(newClass, v => v.id, 0);
+        ctx.sendNode(newClass, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(newClass, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(newClass, v => v.padding.enclosing, Visitor.sendRightPadded(4));
+        ctx.sendNode(newClass, v => v.new, Visitor.sendSpace);
+        ctx.sendNode(newClass, v => v.clazz, ctx.sendTree);
+        ctx.sendNode(newClass, v => v.padding.arguments, Visitor.sendContainer(4));
+        ctx.sendNode(newClass, v => v.body, ctx.sendTree);
+        ctx.sendTypedValue(newClass, v => v.constructorType, 5);
+        return newClass;
+    }
+    visitNullableType(nullableType, ctx) {
+        ctx.sendValue(nullableType, v => v.id, 0);
+        ctx.sendNode(nullableType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(nullableType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(nullableType, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNode(nullableType, v => v.padding.typeTree, Visitor.sendRightPadded(4));
+        return nullableType;
+    }
+    visitPackage(_package, ctx) {
+        ctx.sendValue(_package, v => v.id, 0);
+        ctx.sendNode(_package, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_package, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_package, v => v.expression, ctx.sendTree);
+        ctx.sendNodes(_package, v => v.annotations, ctx.sendTree, t => t.id);
+        return _package;
+    }
+    visitParameterizedType(parameterizedType, ctx) {
+        ctx.sendValue(parameterizedType, v => v.id, 0);
+        ctx.sendNode(parameterizedType, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(parameterizedType, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(parameterizedType, v => v.clazz, ctx.sendTree);
+        ctx.sendNode(parameterizedType, v => v.padding.typeParameters, Visitor.sendContainer(4));
+        ctx.sendTypedValue(parameterizedType, v => v.type, 5);
+        return parameterizedType;
+    }
+    visitParentheses(parentheses, ctx) {
+        ctx.sendValue(parentheses, v => v.id, 0);
+        ctx.sendNode(parentheses, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(parentheses, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(parentheses, v => v.padding.tree, Visitor.sendRightPadded(4));
+        return parentheses;
+    }
+    visitControlParentheses(controlParentheses, ctx) {
+        ctx.sendValue(controlParentheses, v => v.id, 0);
+        ctx.sendNode(controlParentheses, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(controlParentheses, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(controlParentheses, v => v.padding.tree, Visitor.sendRightPadded(4));
+        return controlParentheses;
+    }
+    visitPrimitive(primitive, ctx) {
+        ctx.sendValue(primitive, v => v.id, 0);
+        ctx.sendNode(primitive, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(primitive, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(primitive, v => v.type, 3);
+        return primitive;
+    }
+    visitReturn(_return, ctx) {
+        ctx.sendValue(_return, v => v.id, 0);
+        ctx.sendNode(_return, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_return, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_return, v => v.expression, ctx.sendTree);
+        return _return;
+    }
+    visitSwitch(_switch, ctx) {
+        ctx.sendValue(_switch, v => v.id, 0);
+        ctx.sendNode(_switch, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_switch, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_switch, v => v.selector, ctx.sendTree);
+        ctx.sendNode(_switch, v => v.cases, ctx.sendTree);
+        return _switch;
+    }
+    visitSwitchExpression(switchExpression, ctx) {
+        ctx.sendValue(switchExpression, v => v.id, 0);
+        ctx.sendNode(switchExpression, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(switchExpression, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(switchExpression, v => v.selector, ctx.sendTree);
+        ctx.sendNode(switchExpression, v => v.cases, ctx.sendTree);
+        return switchExpression;
+    }
+    visitSynchronized(synchronized, ctx) {
+        ctx.sendValue(synchronized, v => v.id, 0);
+        ctx.sendNode(synchronized, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(synchronized, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(synchronized, v => v.lock, ctx.sendTree);
+        ctx.sendNode(synchronized, v => v.body, ctx.sendTree);
+        return synchronized;
+    }
+    visitTernary(ternary, ctx) {
+        ctx.sendValue(ternary, v => v.id, 0);
+        ctx.sendNode(ternary, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(ternary, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(ternary, v => v.condition, ctx.sendTree);
+        ctx.sendNode(ternary, v => v.padding.truePart, Visitor.sendLeftPadded(4));
+        ctx.sendNode(ternary, v => v.padding.falsePart, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(ternary, v => v.type, 5);
+        return ternary;
+    }
+    visitThrow(_throw, ctx) {
+        ctx.sendValue(_throw, v => v.id, 0);
+        ctx.sendNode(_throw, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_throw, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_throw, v => v.exception, ctx.sendTree);
+        return _throw;
+    }
+    visitTry(_try, ctx) {
+        ctx.sendValue(_try, v => v.id, 0);
+        ctx.sendNode(_try, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_try, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_try, v => v.padding.resources, Visitor.sendContainer(4));
+        ctx.sendNode(_try, v => v.body, ctx.sendTree);
+        ctx.sendNodes(_try, v => v.catches, ctx.sendTree, t => t.id);
+        ctx.sendNode(_try, v => v.padding.finally, Visitor.sendLeftPadded(4));
+        return _try;
+    }
+    visitTryResource(resource, ctx) {
+        ctx.sendValue(resource, v => v.id, 0);
+        ctx.sendNode(resource, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(resource, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(resource, v => v.variableDeclarations, ctx.sendTree);
+        ctx.sendValue(resource, v => v.terminatedWithSemicolon, 1);
+        return resource;
+    }
+    visitCatch(_catch, ctx) {
+        ctx.sendValue(_catch, v => v.id, 0);
+        ctx.sendNode(_catch, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_catch, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(_catch, v => v.parameter, ctx.sendTree);
+        ctx.sendNode(_catch, v => v.body, ctx.sendTree);
+        return _catch;
+    }
+    visitTypeCast(typeCast, ctx) {
+        ctx.sendValue(typeCast, v => v.id, 0);
+        ctx.sendNode(typeCast, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(typeCast, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(typeCast, v => v.clazz, ctx.sendTree);
+        ctx.sendNode(typeCast, v => v.expression, ctx.sendTree);
+        return typeCast;
+    }
+    visitTypeParameter(typeParameter, ctx) {
+        ctx.sendValue(typeParameter, v => v.id, 0);
+        ctx.sendNode(typeParameter, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(typeParameter, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(typeParameter, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(typeParameter, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(typeParameter, v => v.name, ctx.sendTree);
+        ctx.sendNode(typeParameter, v => v.padding.bounds, Visitor.sendContainer(4));
+        return typeParameter;
+    }
+    visitTypeParameters(typeParameters, ctx) {
+        ctx.sendValue(typeParameters, v => v.id, 0);
+        ctx.sendNode(typeParameters, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(typeParameters, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(typeParameters, v => v.annotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(typeParameters, v => v.padding.typeParameters, Visitor.sendRightPadded(4), t => t.element.id);
+        return typeParameters;
+    }
+    visitUnary(unary, ctx) {
+        ctx.sendValue(unary, v => v.id, 0);
+        ctx.sendNode(unary, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(unary, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(unary, v => v.padding.operator, Visitor.sendLeftPadded(3));
+        ctx.sendNode(unary, v => v.expression, ctx.sendTree);
+        ctx.sendTypedValue(unary, v => v.type, 5);
+        return unary;
+    }
+    visitVariableDeclarations(variableDeclarations, ctx) {
+        ctx.sendValue(variableDeclarations, v => v.id, 0);
+        ctx.sendNode(variableDeclarations, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(variableDeclarations, v => v.markers, ctx.sendMarkers);
+        ctx.sendNodes(variableDeclarations, v => v.leadingAnnotations, ctx.sendTree, t => t.id);
+        ctx.sendNodes(variableDeclarations, v => v.modifiers, ctx.sendTree, t => t.id);
+        ctx.sendNode(variableDeclarations, v => v.typeExpression, ctx.sendTree);
+        ctx.sendNode(variableDeclarations, v => v.varargs, Visitor.sendSpace);
+        ctx.sendNodes(variableDeclarations, v => v.dimensionsBeforeName, Visitor.sendLeftPadded(5), t => t);
+        ctx.sendNodes(variableDeclarations, v => v.padding.variables, Visitor.sendRightPadded(4), t => t.element.id);
+        return variableDeclarations;
+    }
+    visitVariable(namedVariable, ctx) {
+        ctx.sendValue(namedVariable, v => v.id, 0);
+        ctx.sendNode(namedVariable, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(namedVariable, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(namedVariable, v => v.name, ctx.sendTree);
+        ctx.sendNodes(namedVariable, v => v.dimensionsAfterName, Visitor.sendLeftPadded(5), t => t);
+        ctx.sendNode(namedVariable, v => v.padding.initializer, Visitor.sendLeftPadded(4));
+        ctx.sendTypedValue(namedVariable, v => v.variableType, 5);
+        return namedVariable;
+    }
+    visitWhileLoop(whileLoop, ctx) {
+        ctx.sendValue(whileLoop, v => v.id, 0);
+        ctx.sendNode(whileLoop, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(whileLoop, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(whileLoop, v => v.condition, ctx.sendTree);
+        ctx.sendNode(whileLoop, v => v.padding.body, Visitor.sendRightPadded(4));
+        return whileLoop;
+    }
+    visitWildcard(wildcard, ctx) {
+        ctx.sendValue(wildcard, v => v.id, 0);
+        ctx.sendNode(wildcard, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(wildcard, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(wildcard, v => v.padding.bound, Visitor.sendLeftPadded(3));
+        ctx.sendNode(wildcard, v => v.boundedType, ctx.sendTree);
+        return wildcard;
+    }
+    visitYield(_yield, ctx) {
+        ctx.sendValue(_yield, v => v.id, 0);
+        ctx.sendNode(_yield, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(_yield, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(_yield, v => v.implicit, 1);
+        ctx.sendNode(_yield, v => v.value, ctx.sendTree);
+        return _yield;
+    }
+    visitUnknown(unknown, ctx) {
+        ctx.sendValue(unknown, v => v.id, 0);
+        ctx.sendNode(unknown, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(unknown, v => v.markers, ctx.sendMarkers);
+        ctx.sendNode(unknown, v => v.source, ctx.sendTree);
+        return unknown;
+    }
+    visitUnknownSource(source, ctx) {
+        ctx.sendValue(source, v => v.id, 0);
+        ctx.sendNode(source, v => v.prefix, Visitor.sendSpace);
+        ctx.sendNode(source, v => v.markers, ctx.sendMarkers);
+        ctx.sendValue(source, v => v.text, 1);
+        return source;
+    }
+    static sendContainer(type) {
+        return extensions.sendContainer(type);
+    }
+    static sendLeftPadded(type) {
+        return extensions.sendLeftPadded(type);
+    }
+    static sendRightPadded(type) {
+        return extensions.sendRightPadded(type);
+    }
+    static sendSpace(space, ctx) {
+        extensions.sendSpace(space, ctx);
+    }
+}
+//# sourceMappingURL=sender.js.map