@openrewrite/rewrite 8.72.2 → 8.72.4

package/dist/java/rpc.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JavaReceiver = exports.JavaSender = void 0;
 exports.registerJLanguageCodecs = registerJLanguageCodecs;
@@ -34,263 +25,219 @@ const type_1 = require("./type");
 const type_visitor_1 = require("./type-visitor");
 const util_1 = require("../util");
 class TypeSender extends type_visitor_1.TypeVisitor {
-    visitPrimitive(primitive, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(primitive, p => p.keyword);
-            return primitive;
-        });
-    }
-    visitClass(cls, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(cls, c => c.flags);
-            yield q.getAndSend(cls, c => c.classKind);
-            yield q.getAndSend(cls, c => c.fullyQualifiedName);
-            yield q.getAndSendList(cls, c => (c.typeParameters || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), t => this.visit(t, q));
-            yield q.getAndSend(cls, c => (0, rpc_1.asRef)(c.supertype), st => this.visit(st, q));
-            yield q.getAndSend(cls, c => (0, rpc_1.asRef)(c.owningClass), oc => this.visit(oc, q));
-            yield q.getAndSendList(cls, c => (c.annotations || []).map(a => (0, rpc_1.asRef)(a)), t => type_1.Type.signature(t), a => this.visit(a, q));
-            yield q.getAndSendList(cls, c => (c.interfaces || []).map(i => (0, rpc_1.asRef)(i)), t => type_1.Type.signature(t), i => this.visit(i, q));
-            yield q.getAndSendList(cls, c => (c.members || []).map(m => (0, rpc_1.asRef)(m)), t => type_1.Type.signature(t), m => this.visit(m, q));
-            yield q.getAndSendList(cls, c => (c.methods || []).map(m => (0, rpc_1.asRef)(m)), t => type_1.Type.signature(t), m => this.visit(m, q));
-            return cls;
-        });
-    }
-    visitVariable(variable, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(variable, v => v.name);
-            yield q.getAndSend(variable, v => v.owner ? (0, rpc_1.asRef)(v.owner) : undefined, owner => this.visit(owner, q));
-            yield q.getAndSend(variable, v => (0, rpc_1.asRef)(v.type), t => this.visit(t, q));
-            yield q.getAndSendList(variable, v => (v.annotations || []).map(v2 => (0, rpc_1.asRef)(v2)), t => type_1.Type.signature(t), a => this.visit(a, q));
-            return variable;
-        });
-    }
-    visitAnnotation(annotation, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(annotation, a => (0, rpc_1.asRef)(a.type), t => this.visit(t, q));
-            // await q.getAndSendList(annotation, a => (a.values || []).map(v => asRef(v)), v => {
-            //     let value: any;
-            //     if (v.kind === Type.Kind.SingleElementValue) {
-            //         const single = v as Type.Annotation.SingleElementValue;
-            //         value = single.constantValue !== undefined ? single.constantValue : single.referenceValue;
-            //     } else {
-            //         const array = v as Type.Annotation.ArrayElementValue;
-            //         value = array.constantValues || array.referenceValues;
-            //     }
-            //     return `${Type.signature(v.element)}:${value == null ? "null" : value.toString()}`;
-            // }, async v => {
-            //     // Handle element values inline like the Java implementation
-            //     await q.getAndSend(v, e => asRef(e.element), elem => this.visit(elem, q));
-            //     if (v.kind === Type.Kind.SingleElementValue) {
-            //         const single = v as Type.Annotation.SingleElementValue;
-            //         await q.getAndSend(single, s => s.constantValue);
-            //         await q.getAndSend(single, s => asRef(s.referenceValue), ref => this.visit(ref, q));
-            //     } else if (v.kind === Type.Kind.ArrayElementValue) {
-            //         const array = v as Type.Annotation.ArrayElementValue;
-            //         await q.getAndSendList(array, a => a.constantValues || [], val => val == null ? "null" : val.toString());
-            //         await q.getAndSendList(array, a => (a.referenceValues || []).map(r => asRef(r)), t => Type.signature(t), r => this.visit(r, q));
-            //     }
-            // });
-            return annotation;
-        });
-    }
-    visitMethod(method, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(method, m => (0, rpc_1.asRef)(m.declaringType), dt => this.visit(dt, q));
-            yield q.getAndSend(method, m => m.name);
-            yield q.getAndSend(method, m => m.flags);
-            yield q.getAndSend(method, m => (0, rpc_1.asRef)(m.returnType), rt => this.visit(rt, q));
-            yield q.getAndSendList(method, m => m.parameterNames || [], v => v);
-            yield q.getAndSendList(method, m => (m.parameterTypes || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), pt => this.visit(pt, q));
-            yield q.getAndSendList(method, m => (m.thrownExceptions || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), et => this.visit(et, q));
-            yield q.getAndSendList(method, m => (m.annotations || []).map(a => (0, rpc_1.asRef)(a)), t => type_1.Type.signature(t), a => this.visit(a, q));
-            yield q.getAndSendList(method, m => m.defaultValue || undefined, v => v);
-            yield q.getAndSendList(method, m => m.declaredFormalTypeNames || [], v => v);
-            return method;
-        });
-    }
-    visitArray(array, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(array, a => (0, rpc_1.asRef)(a.elemType), et => this.visit(et, q));
-            yield q.getAndSendList(array, a => (a.annotations || []).map(ann => (0, rpc_1.asRef)(ann)), t => type_1.Type.signature(t), ann => this.visit(ann, q));
-            return array;
-        });
-    }
-    visitParameterized(parameterized, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(parameterized, p => (0, rpc_1.asRef)(p.type), t => this.visit(t, q));
-            yield q.getAndSendList(parameterized, p => (p.typeParameters || []).map(tp => (0, rpc_1.asRef)(tp)), t => type_1.Type.signature(t), tp => this.visit(tp, q));
-            return parameterized;
-        });
-    }
-    visitGenericTypeVariable(generic, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(generic, g => g.name);
-            // Convert TypeScript enum to Java enum string
-            yield q.getAndSend(generic, g => {
-                switch (g.variance) {
-                    case type_1.Type.GenericTypeVariable.Variance.Covariant:
-                        return 'COVARIANT';
-                    case type_1.Type.GenericTypeVariable.Variance.Contravariant:
-                        return 'CONTRAVARIANT';
-                    case type_1.Type.GenericTypeVariable.Variance.Invariant:
-                    default:
-                        return 'INVARIANT';
-                }
-            });
-            yield q.getAndSendList(generic, g => (g.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
-            return generic;
+    async visitPrimitive(primitive, q) {
+        await q.getAndSend(primitive, p => p.keyword);
+        return primitive;
+    }
+    async visitClass(cls, q) {
+        await q.getAndSend(cls, c => c.flags);
+        await q.getAndSend(cls, c => c.classKind);
+        await q.getAndSend(cls, c => c.fullyQualifiedName);
+        await q.getAndSendList(cls, c => (c.typeParameters || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), t => this.visit(t, q));
+        await q.getAndSend(cls, c => (0, rpc_1.asRef)(c.supertype), st => this.visit(st, q));
+        await q.getAndSend(cls, c => (0, rpc_1.asRef)(c.owningClass), oc => this.visit(oc, q));
+        await q.getAndSendList(cls, c => (c.annotations || []).map(a => (0, rpc_1.asRef)(a)), t => type_1.Type.signature(t), a => this.visit(a, q));
+        await q.getAndSendList(cls, c => (c.interfaces || []).map(i => (0, rpc_1.asRef)(i)), t => type_1.Type.signature(t), i => this.visit(i, q));
+        await q.getAndSendList(cls, c => (c.members || []).map(m => (0, rpc_1.asRef)(m)), t => type_1.Type.signature(t), m => this.visit(m, q));
+        await q.getAndSendList(cls, c => (c.methods || []).map(m => (0, rpc_1.asRef)(m)), t => type_1.Type.signature(t), m => this.visit(m, q));
+        return cls;
+    }
+    async visitVariable(variable, q) {
+        await q.getAndSend(variable, v => v.name);
+        await q.getAndSend(variable, v => v.owner ? (0, rpc_1.asRef)(v.owner) : undefined, owner => this.visit(owner, q));
+        await q.getAndSend(variable, v => (0, rpc_1.asRef)(v.type), t => this.visit(t, q));
+        await q.getAndSendList(variable, v => (v.annotations || []).map(v2 => (0, rpc_1.asRef)(v2)), t => type_1.Type.signature(t), a => this.visit(a, q));
+        return variable;
+    }
+    async visitAnnotation(annotation, q) {
+        await q.getAndSend(annotation, a => (0, rpc_1.asRef)(a.type), t => this.visit(t, q));
+        // await q.getAndSendList(annotation, a => (a.values || []).map(v => asRef(v)), v => {
+        //     let value: any;
+        //     if (v.kind === Type.Kind.SingleElementValue) {
+        //         const single = v as Type.Annotation.SingleElementValue;
+        //         value = single.constantValue !== undefined ? single.constantValue : single.referenceValue;
+        //     } else {
+        //         const array = v as Type.Annotation.ArrayElementValue;
+        //         value = array.constantValues || array.referenceValues;
+        //     }
+        //     return `${Type.signature(v.element)}:${value == null ? "null" : value.toString()}`;
+        // }, async v => {
+        //     // Handle element values inline like the Java implementation
+        //     await q.getAndSend(v, e => asRef(e.element), elem => this.visit(elem, q));
+        //     if (v.kind === Type.Kind.SingleElementValue) {
+        //         const single = v as Type.Annotation.SingleElementValue;
+        //         await q.getAndSend(single, s => s.constantValue);
+        //         await q.getAndSend(single, s => asRef(s.referenceValue), ref => this.visit(ref, q));
+        //     } else if (v.kind === Type.Kind.ArrayElementValue) {
+        //         const array = v as Type.Annotation.ArrayElementValue;
+        //         await q.getAndSendList(array, a => a.constantValues || [], val => val == null ? "null" : val.toString());
+        //         await q.getAndSendList(array, a => (a.referenceValues || []).map(r => asRef(r)), t => Type.signature(t), r => this.visit(r, q));
+        //     }
+        // });
+        return annotation;
+    }
+    async visitMethod(method, q) {
+        await q.getAndSend(method, m => (0, rpc_1.asRef)(m.declaringType), dt => this.visit(dt, q));
+        await q.getAndSend(method, m => m.name);
+        await q.getAndSend(method, m => m.flags);
+        await q.getAndSend(method, m => (0, rpc_1.asRef)(m.returnType), rt => this.visit(rt, q));
+        await q.getAndSendList(method, m => m.parameterNames || [], v => v);
+        await q.getAndSendList(method, m => (m.parameterTypes || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), pt => this.visit(pt, q));
+        await q.getAndSendList(method, m => (m.thrownExceptions || []).map(t => (0, rpc_1.asRef)(t)), t => type_1.Type.signature(t), et => this.visit(et, q));
+        await q.getAndSendList(method, m => (m.annotations || []).map(a => (0, rpc_1.asRef)(a)), t => type_1.Type.signature(t), a => this.visit(a, q));
+        await q.getAndSendList(method, m => m.defaultValue || undefined, v => v);
+        await q.getAndSendList(method, m => m.declaredFormalTypeNames || [], v => v);
+        return method;
+    }
+    async visitArray(array, q) {
+        await q.getAndSend(array, a => (0, rpc_1.asRef)(a.elemType), et => this.visit(et, q));
+        await q.getAndSendList(array, a => (a.annotations || []).map(ann => (0, rpc_1.asRef)(ann)), t => type_1.Type.signature(t), ann => this.visit(ann, q));
+        return array;
+    }
+    async visitParameterized(parameterized, q) {
+        await q.getAndSend(parameterized, p => (0, rpc_1.asRef)(p.type), t => this.visit(t, q));
+        await q.getAndSendList(parameterized, p => (p.typeParameters || []).map(tp => (0, rpc_1.asRef)(tp)), t => type_1.Type.signature(t), tp => this.visit(tp, q));
+        return parameterized;
+    }
+    async visitGenericTypeVariable(generic, q) {
+        await q.getAndSend(generic, g => g.name);
+        // Convert TypeScript enum to Java enum string
+        await q.getAndSend(generic, g => {
+            switch (g.variance) {
+                case type_1.Type.GenericTypeVariable.Variance.Covariant:
+                    return 'COVARIANT';
+                case type_1.Type.GenericTypeVariable.Variance.Contravariant:
+                    return 'CONTRAVARIANT';
+                case type_1.Type.GenericTypeVariable.Variance.Invariant:
+                default:
+                    return 'INVARIANT';
+            }
         });
+        await q.getAndSendList(generic, g => (g.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
+        return generic;
     }
-    visitUnion(union, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(union, u => (u.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
-            return union;
-        });
+    async visitUnion(union, q) {
+        await q.getAndSendList(union, u => (u.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
+        return union;
     }
-    visitIntersection(intersection, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(intersection, i => (i.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
-            return intersection;
-        });
+    async visitIntersection(intersection, q) {
+        await q.getAndSendList(intersection, i => (i.bounds || []).map(b => (0, rpc_1.asRef)(b)), t => type_1.Type.signature(t), b => this.visit(b, q));
+        return intersection;
     }
 }
 class TypeReceiver extends type_visitor_1.TypeVisitor {
-    preVisit(_type, _q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Don't call default preVisit to avoid circular references
-            return _type;
-        });
-    }
-    postVisit(_type, _q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Don't call default postVisit to avoid circular references
-            return _type;
-        });
-    }
-    visitPrimitive(primitive, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const keyword = yield q.receive(primitive.keyword);
-            return type_1.Type.Primitive.fromKeyword(keyword);
-        });
-    }
-    visitClass(cls, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            cls.flags = yield q.receive(cls.flags);
-            cls.classKind = yield q.receive(cls.classKind);
-            cls.fullyQualifiedName = yield q.receive(cls.fullyQualifiedName);
-            cls.typeParameters = (yield q.receiveList(cls.typeParameters, tp => this.visit(tp, q))) || [];
-            cls.supertype = yield q.receive(cls.supertype, st => this.visit(st, q));
-            cls.owningClass = yield q.receive(cls.owningClass, oc => this.visit(oc, q));
-            cls.annotations = (yield q.receiveList(cls.annotations, a => this.visit(a, q))) || [];
-            cls.interfaces = (yield q.receiveList(cls.interfaces, i => this.visit(i, q))) || [];
-            cls.members = (yield q.receiveList(cls.members, m => this.visit(m, q))) || [];
-            cls.methods = (yield q.receiveList(cls.methods, m => this.visit(m, q))) || [];
-            return cls;
-        });
-    }
-    visitVariable(variable, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            variable.name = yield q.receive(variable.name);
-            variable.owner = yield q.receive(variable.owner, owner => this.visit(owner, q));
-            variable.type = yield q.receive(variable.type, t => this.visit(t, q));
-            variable.annotations = (yield q.receiveList(variable.annotations, a => this.visit(a, q))) || [];
-            return variable;
-        });
-    }
-    visitAnnotation(annotation, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            annotation.type = yield q.receive(annotation.type, t => this.visit(t, q));
-            // annotation.values = await q.receiveList(annotation.values, async v => {
-            //     // Handle element values inline like the Java implementation
-            //     if (v.kind === Type.Kind.SingleElementValue) {
-            //         const single = v as Type.Annotation.SingleElementValue;
-            //         const element = await q.receive(single.element, elem => this.visit(elem, q));
-            //         const constantValue = await q.receive(single.constantValue);
-            //         const referenceValue = await q.receive(single.referenceValue, ref => this.visit(ref, q));
-            //         return {
-            //             kind: Type.Kind.SingleElementValue,
-            //             element,
-            //             constantValue,
-            //             referenceValue
-            //         } as Type.Annotation.SingleElementValue;
-            //     } else if (v.kind === Type.Kind.ArrayElementValue) {
-            //         const array = v as Type.Annotation.ArrayElementValue;
-            //         const element = await q.receive(array.element, elem => this.visit(elem, q));
-            //         const constantValues = await q.receiveList(array.constantValues);
-            //         const referenceValues = await q.receiveList(array.referenceValues, r => this.visit(r, q));
-            //         return {
-            //             kind: Type.Kind.ArrayElementValue,
-            //             element,
-            //             constantValues,
-            //             referenceValues
-            //         } as Type.Annotation.ArrayElementValue;
-            //     }
-            //     return v;
-            // }) || [];
-            return annotation;
-        });
-    }
-    visitMethod(method, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            method.declaringType = yield q.receive(method.declaringType, dt => this.visit(dt, q));
-            method.name = yield q.receive(method.name);
-            method.flags = yield q.receive(method.flags);
-            method.returnType = yield q.receive(method.returnType, rt => this.visit(rt, q));
-            method.parameterNames = (yield q.receiveList(method.parameterNames)) || [];
-            method.parameterTypes = (yield q.receiveList(method.parameterTypes, pt => this.visit(pt, q))) || [];
-            method.thrownExceptions = (yield q.receiveList(method.thrownExceptions, et => this.visit(et, q))) || [];
-            method.annotations = (yield q.receiveList(method.annotations, a => this.visit(a, q))) || [];
-            method.defaultValue = yield q.receiveList(method.defaultValue);
-            method.declaredFormalTypeNames = (yield q.receiveList(method.declaredFormalTypeNames)) || [];
-            return method;
-        });
-    }
-    visitArray(array, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            array.elemType = yield q.receive(array.elemType, et => this.visit(et, q));
-            array.annotations = (yield q.receiveList(array.annotations, ann => this.visit(ann, q))) || [];
-            return array;
-        });
-    }
-    visitParameterized(parameterized, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            parameterized.type = yield q.receive(parameterized.type, t => this.visit(t, q));
-            parameterized.typeParameters = (yield q.receiveList(parameterized.typeParameters, tp => this.visit(tp, q))) || [];
-            return parameterized;
-        });
-    }
-    visitGenericTypeVariable(generic, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            generic.name = yield q.receive(generic.name);
-            const varianceStr = yield q.receive(generic.variance);
-            // Convert Java enum string to TypeScript enum
-            switch (varianceStr) {
-                case 'COVARIANT':
-                    generic.variance = type_1.Type.GenericTypeVariable.Variance.Covariant;
-                    break;
-                case 'CONTRAVARIANT':
-                    generic.variance = type_1.Type.GenericTypeVariable.Variance.Contravariant;
-                    break;
-                case 'INVARIANT':
-                default:
-                    generic.variance = type_1.Type.GenericTypeVariable.Variance.Invariant;
-                    break;
-            }
-            generic.bounds = (yield q.receiveList(generic.bounds, b => this.visit(b, q))) || [];
-            return generic;
-        });
+    async preVisit(_type, _q) {
+        // Don't call default preVisit to avoid circular references
+        return _type;
+    }
+    async postVisit(_type, _q) {
+        // Don't call default postVisit to avoid circular references
+        return _type;
+    }
+    async visitPrimitive(primitive, q) {
+        const keyword = await q.receive(primitive.keyword);
+        return type_1.Type.Primitive.fromKeyword(keyword);
+    }
+    async visitClass(cls, q) {
+        cls.flags = await q.receive(cls.flags);
+        cls.classKind = await q.receive(cls.classKind);
+        cls.fullyQualifiedName = await q.receive(cls.fullyQualifiedName);
+        cls.typeParameters = await q.receiveList(cls.typeParameters, tp => this.visit(tp, q)) || [];
+        cls.supertype = await q.receive(cls.supertype, st => this.visit(st, q));
+        cls.owningClass = await q.receive(cls.owningClass, oc => this.visit(oc, q));
+        cls.annotations = await q.receiveList(cls.annotations, a => this.visit(a, q)) || [];
+        cls.interfaces = await q.receiveList(cls.interfaces, i => this.visit(i, q)) || [];
+        cls.members = await q.receiveList(cls.members, m => this.visit(m, q)) || [];
+        cls.methods = await q.receiveList(cls.methods, m => this.visit(m, q)) || [];
+        return cls;
+    }
+    async visitVariable(variable, q) {
+        variable.name = await q.receive(variable.name);
+        variable.owner = await q.receive(variable.owner, owner => this.visit(owner, q));
+        variable.type = await q.receive(variable.type, t => this.visit(t, q));
+        variable.annotations = await q.receiveList(variable.annotations, a => this.visit(a, q)) || [];
+        return variable;
+    }
+    async visitAnnotation(annotation, q) {
+        annotation.type = await q.receive(annotation.type, t => this.visit(t, q));
+        // annotation.values = await q.receiveList(annotation.values, async v => {
+        //     // Handle element values inline like the Java implementation
+        //     if (v.kind === Type.Kind.SingleElementValue) {
+        //         const single = v as Type.Annotation.SingleElementValue;
+        //         const element = await q.receive(single.element, elem => this.visit(elem, q));
+        //         const constantValue = await q.receive(single.constantValue);
+        //         const referenceValue = await q.receive(single.referenceValue, ref => this.visit(ref, q));
+        //         return {
+        //             kind: Type.Kind.SingleElementValue,
+        //             element,
+        //             constantValue,
+        //             referenceValue
+        //         } as Type.Annotation.SingleElementValue;
+        //     } else if (v.kind === Type.Kind.ArrayElementValue) {
+        //         const array = v as Type.Annotation.ArrayElementValue;
+        //         const element = await q.receive(array.element, elem => this.visit(elem, q));
+        //         const constantValues = await q.receiveList(array.constantValues);
+        //         const referenceValues = await q.receiveList(array.referenceValues, r => this.visit(r, q));
+        //         return {
+        //             kind: Type.Kind.ArrayElementValue,
+        //             element,
+        //             constantValues,
+        //             referenceValues
+        //         } as Type.Annotation.ArrayElementValue;
+        //     }
+        //     return v;
+        // }) || [];
+        return annotation;
+    }
+    async visitMethod(method, q) {
+        method.declaringType = await q.receive(method.declaringType, dt => this.visit(dt, q));
+        method.name = await q.receive(method.name);
+        method.flags = await q.receive(method.flags);
+        method.returnType = await q.receive(method.returnType, rt => this.visit(rt, q));
+        method.parameterNames = await q.receiveList(method.parameterNames) || [];
+        method.parameterTypes = await q.receiveList(method.parameterTypes, pt => this.visit(pt, q)) || [];
+        method.thrownExceptions = await q.receiveList(method.thrownExceptions, et => this.visit(et, q)) || [];
+        method.annotations = await q.receiveList(method.annotations, a => this.visit(a, q)) || [];
+        method.defaultValue = await q.receiveList(method.defaultValue);
+        method.declaredFormalTypeNames = await q.receiveList(method.declaredFormalTypeNames) || [];
+        return method;
+    }
+    async visitArray(array, q) {
+        array.elemType = await q.receive(array.elemType, et => this.visit(et, q));
+        array.annotations = await q.receiveList(array.annotations, ann => this.visit(ann, q)) || [];
+        return array;
+    }
+    async visitParameterized(parameterized, q) {
+        parameterized.type = await q.receive(parameterized.type, t => this.visit(t, q));
+        parameterized.typeParameters = await q.receiveList(parameterized.typeParameters, tp => this.visit(tp, q)) || [];
+        return parameterized;
+    }
+    async visitGenericTypeVariable(generic, q) {
+        generic.name = await q.receive(generic.name);
+        const varianceStr = await q.receive(generic.variance);
+        // Convert Java enum string to TypeScript enum
+        switch (varianceStr) {
+            case 'COVARIANT':
+                generic.variance = type_1.Type.GenericTypeVariable.Variance.Covariant;
+                break;
+            case 'CONTRAVARIANT':
+                generic.variance = type_1.Type.GenericTypeVariable.Variance.Contravariant;
+                break;
+            case 'INVARIANT':
+            default:
+                generic.variance = type_1.Type.GenericTypeVariable.Variance.Invariant;
+                break;
+        }
+        generic.bounds = await q.receiveList(generic.bounds, b => this.visit(b, q)) || [];
+        return generic;
     }
-    visitUnion(union, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            union.bounds = (yield q.receiveList(union.bounds, b => this.visit(b, q))) || [];
-            return union;
-        });
+    async visitUnion(union, q) {
+        union.bounds = await q.receiveList(union.bounds, b => this.visit(b, q)) || [];
+        return union;
     }
-    visitIntersection(intersection, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            intersection.bounds = (yield q.receiveList(intersection.bounds, b => this.visit(b, q))) || [];
-            return intersection;
-        });
+    async visitIntersection(intersection, q) {
+        intersection.bounds = await q.receiveList(intersection.bounds, b => this.visit(b, q)) || [];
+        return intersection;
     }
 }
 class JavaSender extends visitor_1.JavaVisitor {
@@ -298,641 +245,487 @@ class JavaSender extends visitor_1.JavaVisitor {
         super(...arguments);
         this.typeVisitor = new TypeSender();
     }
-    preVisit(j, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(j, j2 => j2.id);
-            yield q.getAndSend(j, j2 => j2.prefix, space => this.visitSpace(space, q));
-            yield q.getAndSend(j, j2 => j2.markers);
-            return j;
-        });
-    }
-    visitAnnotatedType(annotatedType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(annotatedType, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(annotatedType, a => a.typeExpression, type => this.visit(type, q));
-            return annotatedType;
-        });
-    }
-    visitAnnotation(annotation, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(annotation, a => a.annotationType, type => this.visit(type, q));
-            yield q.getAndSend(annotation, a => a.arguments, args => this.visitContainer(args, q));
-            return annotation;
-        });
-    }
-    visitArrayAccess(arrayAccess, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(arrayAccess, a => a.indexed, indexed => this.visit(indexed, q));
-            yield q.getAndSend(arrayAccess, a => a.dimension, dim => this.visit(dim, q));
-            return arrayAccess;
-        });
-    }
-    visitArrayDimension(dimension, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(dimension, d => d.index, idx => this.visitRightPadded(idx, q));
-            return dimension;
-        });
-    }
-    visitArrayType(arrayType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(arrayType, a => a.elementType, type => this.visit(type, q));
-            yield q.getAndSendList(arrayType, a => a.annotations || [], annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(arrayType, a => a.dimension, d => this.visitLeftPadded(d, q));
-            yield q.getAndSend(arrayType, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
-            return arrayType;
-        });
-    }
-    visitAssert(assert, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(assert, a => a.condition, cond => this.visit(cond, q));
-            yield q.getAndSend(assert, a => a.detail, detail => this.visitLeftPadded(detail, q));
-            return assert;
-        });
-    }
-    visitAssignment(assignment, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(assignment, a => a.variable, variable => this.visit(variable, q));
-            yield q.getAndSend(assignment, a => a.assignment, assign => this.visitLeftPadded(assign, q));
-            yield q.getAndSend(assignment, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
-            return assignment;
-        });
-    }
-    visitAssignmentOperation(assignOp, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(assignOp, a => a.variable, variable => this.visit(variable, q));
-            yield q.getAndSend(assignOp, a => a.operator, op => this.visitLeftPadded(op, q));
-            yield q.getAndSend(assignOp, a => a.assignment, assign => this.visit(assign, q));
-            yield q.getAndSend(assignOp, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
-            return assignOp;
-        });
-    }
-    visitBinary(binary, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(binary, b => b.left, left => this.visit(left, q));
-            yield q.getAndSend(binary, b => b.operator, op => this.visitLeftPadded(op, q));
-            yield q.getAndSend(binary, b => b.right, right => this.visit(right, q));
-            yield q.getAndSend(binary, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
-            return binary;
-        });
-    }
-    visitBreak(breakStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(breakStmt, b => b.label, label => this.visit(label, q));
-            return breakStmt;
-        });
-    }
-    visitCase(caseStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(caseStmt, c => c.type);
-            yield q.getAndSend(caseStmt, c => c.caseLabels, labels => this.visitContainer(labels, q));
-            yield q.getAndSend(caseStmt, c => c.statements, stmts => this.visitContainer(stmts, q));
-            yield q.getAndSend(caseStmt, c => c.body, body => this.visitRightPadded(body, q));
-            yield q.getAndSend(caseStmt, c => c.guard, guard => this.visit(guard, q));
-            return caseStmt;
-        });
-    }
-    visitContinue(continueStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(continueStmt, c => c.label, label => this.visit(label, q));
-            return continueStmt;
-        });
-    }
-    visitControlParentheses(controlParens, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(controlParens, c => c.tree, tree => this.visitRightPadded(tree, q));
-            return controlParens;
-        });
-    }
-    visitDeconstructionPattern(pattern, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(pattern, p => p.deconstructor, deconstructor => this.visit(deconstructor, q));
-            yield q.getAndSend(pattern, p => p.nested, nested => this.visitContainer(nested, q));
-            yield q.getAndSend(pattern, p => (0, rpc_1.asRef)(p.type), type => this.visitType(type, q));
-            return pattern;
-        });
-    }
-    visitDoWhileLoop(doWhile, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(doWhile, d => d.body, body => this.visitRightPadded(body, q));
-            yield q.getAndSend(doWhile, d => d.whileCondition, cond => this.visitLeftPadded(cond, q));
-            return doWhile;
-        });
-    }
-    visitEmpty(empty, _q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No additional properties to send
-            return empty;
-        });
-    }
-    visitEnumValueSet(enumValueSet, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(enumValueSet, e => e.enums, enumValue => enumValue.element.id, enumValue => this.visitRightPadded(enumValue, q));
-            yield q.getAndSend(enumValueSet, e => e.terminatedWithSemicolon);
-            return enumValueSet;
-        });
-    }
-    visitEnumValue(enumValue, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(enumValue, e => e.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(enumValue, e => e.name, name => this.visit(name, q));
-            yield q.getAndSend(enumValue, e => e.initializer, init => this.visit(init, q));
-            return enumValue;
-        });
-    }
-    visitErroneous(erroneous, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(erroneous, e => e.text);
-            return erroneous;
-        });
-    }
-    visitFieldAccess(fieldAccess, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(fieldAccess, f => f.target, target => this.visit(target, q));
-            yield q.getAndSend(fieldAccess, f => f.name, name => this.visitLeftPadded(name, q));
-            yield q.getAndSend(fieldAccess, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
-            return fieldAccess;
-        });
-    }
-    visitForEachLoop(forEach, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(forEach, f => f.control, control => this.visit(control, q));
-            yield q.getAndSend(forEach, f => f.body, body => this.visitRightPadded(body, q));
-            return forEach;
-        });
-    }
-    visitForEachLoopControl(control, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(control, c => c.variable, variable => this.visitRightPadded(variable, q));
-            yield q.getAndSend(control, c => c.iterable, iterable => this.visitRightPadded(iterable, q));
-            return control;
-        });
-    }
-    visitForLoop(forLoop, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(forLoop, f => f.control, control => this.visit(control, q));
-            yield q.getAndSend(forLoop, f => f.body, body => this.visitRightPadded(body, q));
-            return forLoop;
-        });
-    }
-    visitForLoopControl(control, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(control, c => c.init, i => i.element.id, i => this.visitRightPadded(i, q));
-            yield q.getAndSend(control, c => c.condition, c => this.visitRightPadded(c, q));
-            yield q.getAndSendList(control, c => c.update, u => u.element.id, u => this.visitRightPadded(u, q));
-            return control;
-        });
-    }
-    visitIf(ifStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(ifStmt, i => i.ifCondition, cond => this.visit(cond, q));
-            yield q.getAndSend(ifStmt, i => i.thenPart, then => this.visitRightPadded(then, q));
-            yield q.getAndSend(ifStmt, i => i.elsePart, elsePart => this.visit(elsePart, q));
-            return ifStmt;
-        });
-    }
-    visitElse(ifElse, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(ifElse, e => e.body, body => this.visitRightPadded(body, q));
-            return ifElse;
-        });
-    }
-    visitImport(importStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(importStmt, i => i.static, static_ => this.visitLeftPadded(static_, q));
-            yield q.getAndSend(importStmt, i => i.qualid, qualid => this.visit(qualid, q));
-            yield q.getAndSend(importStmt, i => i.alias, alias => this.visitLeftPadded(alias, q));
-            return importStmt;
-        });
-    }
-    visitInstanceOf(instanceOf, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(instanceOf, i => i.expression, expr => this.visitRightPadded(expr, q));
-            yield q.getAndSend(instanceOf, i => i.class, clazz => this.visit(clazz, q));
-            yield q.getAndSend(instanceOf, i => i.pattern, pattern => this.visit(pattern, q));
-            yield q.getAndSend(instanceOf, i => (0, rpc_1.asRef)(i.type), type => this.visitType(type, q));
-            yield q.getAndSend(instanceOf, i => i.modifier, modifier => this.visit(modifier, q));
-            return instanceOf;
-        });
-    }
-    visitIntersectionType(intersectionType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(intersectionType, i => i.bounds, bounds => this.visitContainer(bounds, q));
-            return intersectionType;
-        });
-    }
-    visitLabel(label, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(label, l => l.label, id => this.visitRightPadded(id, q));
-            yield q.getAndSend(label, l => l.statement, stmt => this.visit(stmt, q));
-            return label;
-        });
-    }
-    visitLambda(lambda, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(lambda, l => l.parameters, params => this.visit(params, q));
-            yield q.getAndSend(lambda, l => l.arrow, arrow => this.visitSpace(arrow, q));
-            yield q.getAndSend(lambda, l => l.body, body => this.visit(body, q));
-            yield q.getAndSend(lambda, l => (0, rpc_1.asRef)(l.type), type => this.visitType(type, q));
-            return lambda;
-        });
-    }
-    visitLambdaParameters(params, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(params, p => p.parenthesized);
-            yield q.getAndSendList(params, p => p.parameters, param => param.element.id, param => this.visitRightPadded(param, q));
-            return params;
-        });
-    }
-    visitLiteral(literal, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(literal, l => l.value);
-            yield q.getAndSend(literal, l => l.valueSource);
-            yield q.getAndSendList(literal, l => l.unicodeEscapes, e => e.valueSourceIndex + e.codePoint);
-            yield q.getAndSend(literal, l => (0, rpc_1.asRef)(l.type), type => this.visitType(type, q));
-            return literal;
-        });
-    }
-    visitMemberReference(memberRef, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(memberRef, m => m.containing, cont => this.visitRightPadded(cont, q));
-            yield q.getAndSend(memberRef, m => m.typeParameters, params => this.visitContainer(params, q));
-            yield q.getAndSend(memberRef, m => m.reference, ref => this.visitLeftPadded(ref, q));
-            yield q.getAndSend(memberRef, m => (0, rpc_1.asRef)(m.type), type => this.visitType(type, q));
-            yield q.getAndSend(memberRef, m => (0, rpc_1.asRef)(m.methodType), type => this.visitType(type, q));
-            yield q.getAndSend(memberRef, m => (0, rpc_1.asRef)(m.variableType), type => this.visitType(type, q));
-            return memberRef;
-        });
-    }
-    visitMethodInvocation(invocation, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(invocation, m => m.select, select => this.visitRightPadded(select, q));
-            yield q.getAndSend(invocation, m => m.typeParameters, params => this.visitContainer(params, q));
-            yield q.getAndSend(invocation, m => m.name, name => this.visit(name, q));
-            yield q.getAndSend(invocation, m => m.arguments, args => this.visitContainer(args, q));
-            yield q.getAndSend(invocation, m => (0, rpc_1.asRef)(m.methodType), type => this.visitType(type, q));
-            return invocation;
-        });
-    }
-    visitModifier(modifier, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(modifier, m => m.keyword);
-            yield q.getAndSend(modifier, m => m.type);
-            yield q.getAndSendList(modifier, m => m.annotations, annot => annot.id, annot => this.visit(annot, q));
-            return modifier;
-        });
-    }
-    visitMultiCatch(multiCatch, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(multiCatch, m => m.alternatives, alt => alt.element.id, alt => this.visitRightPadded(alt, q));
-            return multiCatch;
-        });
-    }
-    visitNewArray(newArray, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(newArray, n => n.typeExpression, type => this.visit(type, q));
-            yield q.getAndSendList(newArray, n => n.dimensions, dim => dim.id, dim => this.visit(dim, q));
-            yield q.getAndSend(newArray, n => n.initializer, init => this.visitContainer(init, q));
-            yield q.getAndSend(newArray, n => (0, rpc_1.asRef)(n.type), type => this.visitType(type, q));
-            return newArray;
-        });
-    }
-    visitNewClass(newClass, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(newClass, n => n.enclosing, encl => this.visitRightPadded(encl, q));
-            yield q.getAndSend(newClass, n => n.new, n => this.visitSpace(n, q));
-            yield q.getAndSend(newClass, n => n.class, clazz => this.visit(clazz, q));
-            yield q.getAndSend(newClass, n => n.arguments, args => this.visitContainer(args, q));
-            yield q.getAndSend(newClass, n => n.body, body => this.visit(body, q));
-            yield q.getAndSend(newClass, n => (0, rpc_1.asRef)(n.constructorType), type => this.visitType(type, q));
-            return newClass;
-        });
-    }
-    visitNullableType(nullableType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(nullableType, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(nullableType, n => n.typeTree, type => this.visitRightPadded(type, q));
-            return nullableType;
-        });
-    }
-    visitParameterizedType(paramType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(paramType, p => p.class, clazz => this.visit(clazz, q));
-            yield q.getAndSend(paramType, p => p.typeParameters, params => this.visitContainer(params, q));
-            yield q.getAndSend(paramType, p => (0, rpc_1.asRef)(p.type), type => this.visitType(type, q));
-            return paramType;
-        });
-    }
-    visitParentheses(parentheses, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(parentheses, p => p.tree, tree => this.visitRightPadded(tree, q));
-            return parentheses;
-        });
-    }
-    visitParenthesizedTypeTree(parenthesizedType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(parenthesizedType, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(parenthesizedType, p => p.parenthesizedType, tree => this.visit(tree, q));
-            return parenthesizedType;
-        });
-    }
-    visitPrimitive(primitive, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(primitive, p => (0, rpc_1.asRef)(p.type), type => this.visitType(type, q));
-            return primitive;
-        });
-    }
-    visitReturn(returnStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(returnStmt, r => r.expression, expr => this.visit(expr, q));
-            return returnStmt;
-        });
-    }
-    visitSwitch(aSwitch, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(aSwitch, s => s.selector, sel => this.visit(sel, q));
-            yield q.getAndSend(aSwitch, s => s.cases, block => this.visit(block, q));
-            return aSwitch;
-        });
-    }
-    visitSwitchExpression(switchExpr, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(switchExpr, s => s.selector, sel => this.visit(sel, q));
-            yield q.getAndSend(switchExpr, s => s.cases, block => this.visit(block, q));
-            yield q.getAndSend(switchExpr, s => (0, rpc_1.asRef)(s.type), type => this.visitType(type, q));
-            return switchExpr;
-        });
-    }
-    visitSynchronized(syncStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(syncStmt, s => s.lock, lock => this.visit(lock, q));
-            yield q.getAndSend(syncStmt, s => s.body, body => this.visit(body, q));
-            return syncStmt;
-        });
-    }
-    visitTernary(ternary, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(ternary, t => t.condition, cond => this.visit(cond, q));
-            yield q.getAndSend(ternary, t => t.truePart, truePart => this.visitLeftPadded(truePart, q));
-            yield q.getAndSend(ternary, t => t.falsePart, falsePart => this.visitLeftPadded(falsePart, q));
-            yield q.getAndSend(ternary, t => (0, rpc_1.asRef)(t.type), type => this.visitType(type, q));
-            return ternary;
-        });
-    }
-    visitThrow(throwStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(throwStmt, t => t.exception, exc => this.visit(exc, q));
-            return throwStmt;
-        });
-    }
-    visitTry(tryStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(tryStmt, t => t.resources, res => this.visitContainer(res, q));
-            yield q.getAndSend(tryStmt, t => t.body, body => this.visit(body, q));
-            yield q.getAndSendList(tryStmt, t => t.catches, catch_ => catch_.id, catch_ => this.visit(catch_, q));
-            yield q.getAndSend(tryStmt, t => t.finally, fin => this.visitLeftPadded(fin, q));
-            return tryStmt;
-        });
-    }
-    visitTryResource(resource, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(resource, r => r.variableDeclarations, variable => this.visit(variable, q));
-            yield q.getAndSend(resource, r => r.terminatedWithSemicolon);
-            return resource;
-        });
-    }
-    visitTryCatch(aCatch, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(aCatch, c => c.parameter, param => this.visit(param, q));
-            yield q.getAndSend(aCatch, c => c.body, body => this.visit(body, q));
-            return aCatch;
-        });
-    }
-    visitTypeCast(typeCast, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(typeCast, t => t.class, clazz => this.visit(clazz, q));
-            yield q.getAndSend(typeCast, t => t.expression, expr => this.visit(expr, q));
-            return typeCast;
-        });
-    }
-    visitTypeParameter(typeParam, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(typeParam, t => t.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSendList(typeParam, t => t.modifiers, mod => mod.id, mod => this.visit(mod, q));
-            yield q.getAndSend(typeParam, t => t.name, name => this.visit(name, q));
-            yield q.getAndSend(typeParam, t => t.bounds, bounds => this.visitContainer(bounds, q));
-            return typeParam;
-        });
-    }
-    visitTypeParameters(typeParams, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(typeParams, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSendList(typeParams, t => t.typeParameters, p => p.element.id, params => this.visitRightPadded(params, q));
-            return typeParams;
-        });
-    }
-    visitUnary(unary, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(unary, u => u.operator, op => this.visitLeftPadded(op, q));
-            yield q.getAndSend(unary, u => u.expression, expr => this.visit(expr, q));
-            yield q.getAndSend(unary, u => (0, rpc_1.asRef)(u.type), type => this.visitType(type, q));
-            return unary;
-        });
-    }
-    visitVariable(variable, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(variable, v => v.name, name => this.visit(name, q));
-            yield q.getAndSendList(variable, v => v.dimensionsAfterName, d => JSON.stringify(d.element), dims => this.visitLeftPadded(dims, q));
-            yield q.getAndSend(variable, v => v.initializer, init => this.visitLeftPadded(init, q));
-            yield q.getAndSend(variable, v => (0, rpc_1.asRef)(v.variableType), type => this.visitType(type, q));
-            return variable;
-        });
-    }
-    visitWhileLoop(whileLoop, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(whileLoop, w => w.condition, cond => this.visit(cond, q));
-            yield q.getAndSend(whileLoop, w => w.body, body => this.visitRightPadded(body, q));
-            return whileLoop;
-        });
-    }
-    visitWildcard(wildcard, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(wildcard, w => w.bound, b => this.visitLeftPadded(b, q));
-            yield q.getAndSend(wildcard, w => w.boundedType, type => this.visit(type, q));
-            return wildcard;
-        });
-    }
-    visitYield(yieldExpr, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(yieldExpr, y => y.implicit);
-            yield q.getAndSend(yieldExpr, y => y.value, value => this.visit(value, q));
-            return yieldExpr;
-        });
-    }
-    visitUnknown(unknown, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(unknown, u => u.source, source => this.visit(source, q));
-            return unknown;
-        });
-    }
-    visitUnknownSource(source, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(source, s => s.text);
-            return source;
-        });
-    }
-    visitCompilationUnit(cu, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(cu, c => c.sourcePath);
-            yield q.getAndSend(cu, c => c.charsetName);
-            yield q.getAndSend(cu, c => c.charsetBomMarked);
-            yield q.getAndSend(cu, c => c.checksum);
-            yield q.getAndSend(cu, c => c.fileAttributes);
-            yield q.getAndSend(cu, c => c.packageDeclaration, pkg => this.visitRightPadded(pkg, q));
-            yield q.getAndSendList(cu, c => c.imports, imp => imp.element.id, imp => this.visitRightPadded(imp, q));
-            yield q.getAndSendList(cu, c => c.classes, cls => cls.id, cls => this.visit(cls, q));
-            yield q.getAndSend(cu, c => c.eof, space => this.visitSpace(space, q));
-            return cu;
-        });
-    }
-    visitPackage(pkg, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(pkg, p => p.expression, expr => this.visit(expr, q));
-            yield q.getAndSendList(pkg, p => p.annotations, annot => annot.id, annot => this.visit(annot, q));
-            return pkg;
-        });
-    }
-    visitClassDeclaration(cls, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(cls, c => c.leadingAnnotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSendList(cls, c => c.modifiers, mod => mod.id, mod => this.visit(mod, q));
-            yield q.getAndSend(cls, c => c.classKind, kind => this.visit(kind, q));
-            yield q.getAndSend(cls, c => c.name, name => this.visit(name, q));
-            yield q.getAndSend(cls, c => c.typeParameters, params => this.visitContainer(params, q));
-            yield q.getAndSend(cls, c => c.primaryConstructor, cons => this.visitContainer(cons, q));
-            yield q.getAndSend(cls, c => c.extends, ext => this.visitLeftPadded(ext, q));
-            yield q.getAndSend(cls, c => c.implements, impl => this.visitContainer(impl, q));
-            yield q.getAndSend(cls, c => c.permitting, perm => this.visitContainer(perm, q));
-            yield q.getAndSend(cls, c => c.body, body => this.visit(body, q));
-            return cls;
-        });
-    }
-    visitClassDeclarationKind(kind, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(kind, k => k.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(kind, k => k.type);
-            return kind;
-        });
-    }
-    visitBlock(block, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(block, b => b.static, s => this.visitRightPadded(s, q));
-            yield q.getAndSendList(block, b => b.statements, stmt => stmt.element.id, stmt => this.visitRightPadded(stmt, q));
-            yield q.getAndSend(block, b => b.end, space => this.visitSpace(space, q));
-            return block;
-        });
-    }
-    visitMethodDeclaration(method, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(method, m => m.leadingAnnotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSendList(method, m => m.modifiers, mod => mod.id, mod => this.visit(mod, q));
-            yield q.getAndSend(method, m => m.typeParameters, params => this.visit(params, q));
-            yield q.getAndSend(method, m => m.returnTypeExpression, type => this.visit(type, q));
-            yield q.getAndSendList(method, m => m.nameAnnotations, a => a.id, name => this.visit(name, q));
-            yield q.getAndSend(method, m => m.name, name => this.visit(name, q));
-            yield q.getAndSend(method, m => m.parameters, params => this.visitContainer(params, q));
-            yield q.getAndSend(method, m => m.throws, throws => this.visitContainer(throws, q));
-            yield q.getAndSend(method, m => m.body, body => this.visit(body, q));
-            yield q.getAndSend(method, m => m.defaultValue, def => this.visitLeftPadded(def, q));
-            yield q.getAndSend(method, m => (0, rpc_1.asRef)(m.methodType), type => this.visitType(type, q));
-            return method;
-        });
-    }
-    visitVariableDeclarations(varDecls, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(varDecls, v => v.leadingAnnotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSendList(varDecls, v => v.modifiers, mod => mod.id, mod => this.visit(mod, q));
-            yield q.getAndSend(varDecls, v => v.typeExpression, type => this.visit(type, q));
-            yield q.getAndSend(varDecls, v => v.varargs, space => this.visitSpace(space, q));
-            yield q.getAndSendList(varDecls, v => v.variables, variable => variable.element.id, variable => this.visitRightPadded(variable, q));
-            return varDecls;
-        });
-    }
-    visitIdentifier(ident, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(ident, id => id.annotations, annot => annot.id, annot => this.visit(annot, q));
-            yield q.getAndSend(ident, id => id.simpleName);
-            yield q.getAndSend(ident, id => (0, rpc_1.asRef)(id.type), type => this.visitType(type, q));
-            yield q.getAndSend(ident, id => (0, rpc_1.asRef)(id.fieldType), type => this.visitType(type, q));
-            return ident;
-        });
-    }
-    visitSpace(space, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSendList(space, s => s.comments, c => {
-                if (c.kind === tree_1.J.Kind.TextComment) {
-                    return c.text + c.suffix;
-                }
-                throw new Error(`Unexpected comment type ${c.kind}`);
-            }, (c) => __awaiter(this, void 0, void 0, function* () {
-                if (c.kind === tree_1.J.Kind.TextComment) {
-                    const tc = c;
-                    yield q.getAndSend(tc, c2 => c2.multiline);
-                    yield q.getAndSend(tc, c2 => c2.text);
-                }
-                else {
-                    throw new Error(`Unexpected comment type ${c.kind}`);
-                }
-                yield q.getAndSend(c, c2 => c2.suffix);
-                yield q.getAndSend(c, c2 => c2.markers);
-            }));
-            yield q.getAndSend(space, s => s.whitespace);
-            return space;
-        });
-    }
-    visitLeftPadded(left, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(left, l => l.before, space => this.visitSpace(space, q));
-            if ((0, tree_2.isTree)(left.element)) {
-                yield q.getAndSend(left, l => l.element, elem => this.visit(elem, q));
-            }
-            else if ((0, tree_1.isSpace)(left.element)) {
-                yield q.getAndSend(left, l => l.element, space => this.visitSpace(space, q));
-            }
-            else {
-                yield q.getAndSend(left, l => l.element);
+    async preVisit(j, q) {
+        await q.getAndSend(j, j2 => j2.id);
+        await q.getAndSend(j, j2 => j2.prefix, space => this.visitSpace(space, q));
+        await q.getAndSend(j, j2 => j2.markers);
+        return j;
+    }
+    async visitAnnotatedType(annotatedType, q) {
+        await q.getAndSendList(annotatedType, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(annotatedType, a => a.typeExpression, type => this.visit(type, q));
+        return annotatedType;
+    }
+    async visitAnnotation(annotation, q) {
+        await q.getAndSend(annotation, a => a.annotationType, type => this.visit(type, q));
+        await q.getAndSend(annotation, a => a.arguments, args => this.visitContainer(args, q));
+        return annotation;
+    }
+    async visitArrayAccess(arrayAccess, q) {
+        await q.getAndSend(arrayAccess, a => a.indexed, indexed => this.visit(indexed, q));
+        await q.getAndSend(arrayAccess, a => a.dimension, dim => this.visit(dim, q));
+        return arrayAccess;
+    }
+    async visitArrayDimension(dimension, q) {
+        await q.getAndSend(dimension, d => d.index, idx => this.visitRightPadded(idx, q));
+        return dimension;
+    }
+    async visitArrayType(arrayType, q) {
+        await q.getAndSend(arrayType, a => a.elementType, type => this.visit(type, q));
+        await q.getAndSendList(arrayType, a => a.annotations || [], annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(arrayType, a => a.dimension, d => this.visitLeftPadded(d, q));
+        await q.getAndSend(arrayType, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
+        return arrayType;
+    }
+    async visitAssert(assert, q) {
+        await q.getAndSend(assert, a => a.condition, cond => this.visit(cond, q));
+        await q.getAndSend(assert, a => a.detail, detail => this.visitLeftPadded(detail, q));
+        return assert;
+    }
+    async visitAssignment(assignment, q) {
+        await q.getAndSend(assignment, a => a.variable, variable => this.visit(variable, q));
+        await q.getAndSend(assignment, a => a.assignment, assign => this.visitLeftPadded(assign, q));
+        await q.getAndSend(assignment, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
+        return assignment;
+    }
+    async visitAssignmentOperation(assignOp, q) {
+        await q.getAndSend(assignOp, a => a.variable, variable => this.visit(variable, q));
+        await q.getAndSend(assignOp, a => a.operator, op => this.visitLeftPadded(op, q));
+        await q.getAndSend(assignOp, a => a.assignment, assign => this.visit(assign, q));
+        await q.getAndSend(assignOp, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
+        return assignOp;
+    }
+    async visitBinary(binary, q) {
+        await q.getAndSend(binary, b => b.left, left => this.visit(left, q));
+        await q.getAndSend(binary, b => b.operator, op => this.visitLeftPadded(op, q));
+        await q.getAndSend(binary, b => b.right, right => this.visit(right, q));
+        await q.getAndSend(binary, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
+        return binary;
+    }
+    async visitBreak(breakStmt, q) {
+        await q.getAndSend(breakStmt, b => b.label, label => this.visit(label, q));
+        return breakStmt;
+    }
+    async visitCase(caseStmt, q) {
+        await q.getAndSend(caseStmt, c => c.type);
+        await q.getAndSend(caseStmt, c => c.caseLabels, labels => this.visitContainer(labels, q));
+        await q.getAndSend(caseStmt, c => c.statements, stmts => this.visitContainer(stmts, q));
+        await q.getAndSend(caseStmt, c => c.body, body => this.visitRightPadded(body, q));
+        await q.getAndSend(caseStmt, c => c.guard, guard => this.visit(guard, q));
+        return caseStmt;
+    }
+    async visitContinue(continueStmt, q) {
+        await q.getAndSend(continueStmt, c => c.label, label => this.visit(label, q));
+        return continueStmt;
+    }
+    async visitControlParentheses(controlParens, q) {
+        await q.getAndSend(controlParens, c => c.tree, tree => this.visitRightPadded(tree, q));
+        return controlParens;
+    }
+    async visitDeconstructionPattern(pattern, q) {
+        await q.getAndSend(pattern, p => p.deconstructor, deconstructor => this.visit(deconstructor, q));
+        await q.getAndSend(pattern, p => p.nested, nested => this.visitContainer(nested, q));
+        await q.getAndSend(pattern, p => (0, rpc_1.asRef)(p.type), type => this.visitType(type, q));
+        return pattern;
+    }
+    async visitDoWhileLoop(doWhile, q) {
+        await q.getAndSend(doWhile, d => d.body, body => this.visitRightPadded(body, q));
+        await q.getAndSend(doWhile, d => d.whileCondition, cond => this.visitLeftPadded(cond, q));
+        return doWhile;
+    }
+    async visitEmpty(empty, _q) {
+        // No additional properties to send
+        return empty;
+    }
+    async visitEnumValueSet(enumValueSet, q) {
+        await q.getAndSendList(enumValueSet, e => e.enums, enumValue => enumValue.element.id, enumValue => this.visitRightPadded(enumValue, q));
+        await q.getAndSend(enumValueSet, e => e.terminatedWithSemicolon);
+        return enumValueSet;
+    }
+    async visitEnumValue(enumValue, q) {
+        await q.getAndSendList(enumValue, e => e.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(enumValue, e => e.name, name => this.visit(name, q));
+        await q.getAndSend(enumValue, e => e.initializer, init => this.visit(init, q));
+        return enumValue;
+    }
+    async visitErroneous(erroneous, q) {
+        await q.getAndSend(erroneous, e => e.text);
+        return erroneous;
+    }
+    async visitFieldAccess(fieldAccess, q) {
+        await q.getAndSend(fieldAccess, f => f.target, target => this.visit(target, q));
+        await q.getAndSend(fieldAccess, f => f.name, name => this.visitLeftPadded(name, q));
+        await q.getAndSend(fieldAccess, a => (0, rpc_1.asRef)(a.type), type => this.visitType(type, q));
+        return fieldAccess;
+    }
+    async visitForEachLoop(forEach, q) {
+        await q.getAndSend(forEach, f => f.control, control => this.visit(control, q));
+        await q.getAndSend(forEach, f => f.body, body => this.visitRightPadded(body, q));
+        return forEach;
+    }
+    async visitForEachLoopControl(control, q) {
+        await q.getAndSend(control, c => c.variable, variable => this.visitRightPadded(variable, q));
+        await q.getAndSend(control, c => c.iterable, iterable => this.visitRightPadded(iterable, q));
+        return control;
+    }
+    async visitForLoop(forLoop, q) {
+        await q.getAndSend(forLoop, f => f.control, control => this.visit(control, q));
+        await q.getAndSend(forLoop, f => f.body, body => this.visitRightPadded(body, q));
+        return forLoop;
+    }
+    async visitForLoopControl(control, q) {
+        await q.getAndSendList(control, c => c.init, i => i.element.id, i => this.visitRightPadded(i, q));
+        await q.getAndSend(control, c => c.condition, c => this.visitRightPadded(c, q));
+        await q.getAndSendList(control, c => c.update, u => u.element.id, u => this.visitRightPadded(u, q));
+        return control;
+    }
+    async visitIf(ifStmt, q) {
+        await q.getAndSend(ifStmt, i => i.ifCondition, cond => this.visit(cond, q));
+        await q.getAndSend(ifStmt, i => i.thenPart, then => this.visitRightPadded(then, q));
+        await q.getAndSend(ifStmt, i => i.elsePart, elsePart => this.visit(elsePart, q));
+        return ifStmt;
+    }
+    async visitElse(ifElse, q) {
+        await q.getAndSend(ifElse, e => e.body, body => this.visitRightPadded(body, q));
+        return ifElse;
+    }
+    async visitImport(importStmt, q) {
+        await q.getAndSend(importStmt, i => i.static, static_ => this.visitLeftPadded(static_, q));
+        await q.getAndSend(importStmt, i => i.qualid, qualid => this.visit(qualid, q));
+        await q.getAndSend(importStmt, i => i.alias, alias => this.visitLeftPadded(alias, q));
+        return importStmt;
+    }
+    async visitInstanceOf(instanceOf, q) {
+        await q.getAndSend(instanceOf, i => i.expression, expr => this.visitRightPadded(expr, q));
+        await q.getAndSend(instanceOf, i => i.class, clazz => this.visit(clazz, q));
+        await q.getAndSend(instanceOf, i => i.pattern, pattern => this.visit(pattern, q));
+        await q.getAndSend(instanceOf, i => (0, rpc_1.asRef)(i.type), type => this.visitType(type, q));
+        await q.getAndSend(instanceOf, i => i.modifier, modifier => this.visit(modifier, q));
+        return instanceOf;
+    }
+    async visitIntersectionType(intersectionType, q) {
+        await q.getAndSend(intersectionType, i => i.bounds, bounds => this.visitContainer(bounds, q));
+        return intersectionType;
+    }
+    async visitLabel(label, q) {
+        await q.getAndSend(label, l => l.label, id => this.visitRightPadded(id, q));
+        await q.getAndSend(label, l => l.statement, stmt => this.visit(stmt, q));
+        return label;
+    }
+    async visitLambda(lambda, q) {
+        await q.getAndSend(lambda, l => l.parameters, params => this.visit(params, q));
+        await q.getAndSend(lambda, l => l.arrow, arrow => this.visitSpace(arrow, q));
+        await q.getAndSend(lambda, l => l.body, body => this.visit(body, q));
+        await q.getAndSend(lambda, l => (0, rpc_1.asRef)(l.type), type => this.visitType(type, q));
+        return lambda;
+    }
+    async visitLambdaParameters(params, q) {
+        await q.getAndSend(params, p => p.parenthesized);
+        await q.getAndSendList(params, p => p.parameters, param => param.element.id, param => this.visitRightPadded(param, q));
+        return params;
+    }
+    async visitLiteral(literal, q) {
+        await q.getAndSend(literal, l => l.value);
+        await q.getAndSend(literal, l => l.valueSource);
+        await q.getAndSendList(literal, l => l.unicodeEscapes, e => e.valueSourceIndex + e.codePoint);
+        await q.getAndSend(literal, l => (0, rpc_1.asRef)(l.type), type => this.visitType(type, q));
+        return literal;
+    }
+    async visitMemberReference(memberRef, q) {
+        await q.getAndSend(memberRef, m => m.containing, cont => this.visitRightPadded(cont, q));
+        await q.getAndSend(memberRef, m => m.typeParameters, params => this.visitContainer(params, q));
+        await q.getAndSend(memberRef, m => m.reference, ref => this.visitLeftPadded(ref, q));
+        await q.getAndSend(memberRef, m => (0, rpc_1.asRef)(m.type), type => this.visitType(type, q));
+        await q.getAndSend(memberRef, m => (0, rpc_1.asRef)(m.methodType), type => this.visitType(type, q));
+        await q.getAndSend(memberRef, m => (0, rpc_1.asRef)(m.variableType), type => this.visitType(type, q));
+        return memberRef;
+    }
+    async visitMethodInvocation(invocation, q) {
+        await q.getAndSend(invocation, m => m.select, select => this.visitRightPadded(select, q));
+        await q.getAndSend(invocation, m => m.typeParameters, params => this.visitContainer(params, q));
+        await q.getAndSend(invocation, m => m.name, name => this.visit(name, q));
+        await q.getAndSend(invocation, m => m.arguments, args => this.visitContainer(args, q));
+        await q.getAndSend(invocation, m => (0, rpc_1.asRef)(m.methodType), type => this.visitType(type, q));
+        return invocation;
+    }
+    async visitModifier(modifier, q) {
+        await q.getAndSend(modifier, m => m.keyword);
+        await q.getAndSend(modifier, m => m.type);
+        await q.getAndSendList(modifier, m => m.annotations, annot => annot.id, annot => this.visit(annot, q));
+        return modifier;
+    }
+    async visitMultiCatch(multiCatch, q) {
+        await q.getAndSendList(multiCatch, m => m.alternatives, alt => alt.element.id, alt => this.visitRightPadded(alt, q));
+        return multiCatch;
+    }
+    async visitNewArray(newArray, q) {
+        await q.getAndSend(newArray, n => n.typeExpression, type => this.visit(type, q));
+        await q.getAndSendList(newArray, n => n.dimensions, dim => dim.id, dim => this.visit(dim, q));
+        await q.getAndSend(newArray, n => n.initializer, init => this.visitContainer(init, q));
+        await q.getAndSend(newArray, n => (0, rpc_1.asRef)(n.type), type => this.visitType(type, q));
+        return newArray;
+    }
+    async visitNewClass(newClass, q) {
+        await q.getAndSend(newClass, n => n.enclosing, encl => this.visitRightPadded(encl, q));
+        await q.getAndSend(newClass, n => n.new, n => this.visitSpace(n, q));
+        await q.getAndSend(newClass, n => n.class, clazz => this.visit(clazz, q));
+        await q.getAndSend(newClass, n => n.arguments, args => this.visitContainer(args, q));
+        await q.getAndSend(newClass, n => n.body, body => this.visit(body, q));
+        await q.getAndSend(newClass, n => (0, rpc_1.asRef)(n.constructorType), type => this.visitType(type, q));
+        return newClass;
+    }
+    async visitNullableType(nullableType, q) {
+        await q.getAndSendList(nullableType, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(nullableType, n => n.typeTree, type => this.visitRightPadded(type, q));
+        return nullableType;
+    }
+    async visitParameterizedType(paramType, q) {
+        await q.getAndSend(paramType, p => p.class, clazz => this.visit(clazz, q));
+        await q.getAndSend(paramType, p => p.typeParameters, params => this.visitContainer(params, q));
+        await q.getAndSend(paramType, p => (0, rpc_1.asRef)(p.type), type => this.visitType(type, q));
+        return paramType;
+    }
+    async visitParentheses(parentheses, q) {
+        await q.getAndSend(parentheses, p => p.tree, tree => this.visitRightPadded(tree, q));
+        return parentheses;
+    }
+    async visitParenthesizedTypeTree(parenthesizedType, q) {
+        await q.getAndSendList(parenthesizedType, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(parenthesizedType, p => p.parenthesizedType, tree => this.visit(tree, q));
+        return parenthesizedType;
+    }
+    async visitPrimitive(primitive, q) {
+        await q.getAndSend(primitive, p => (0, rpc_1.asRef)(p.type), type => this.visitType(type, q));
+        return primitive;
+    }
+    async visitReturn(returnStmt, q) {
+        await q.getAndSend(returnStmt, r => r.expression, expr => this.visit(expr, q));
+        return returnStmt;
+    }
+    async visitSwitch(aSwitch, q) {
+        await q.getAndSend(aSwitch, s => s.selector, sel => this.visit(sel, q));
+        await q.getAndSend(aSwitch, s => s.cases, block => this.visit(block, q));
+        return aSwitch;
+    }
+    async visitSwitchExpression(switchExpr, q) {
+        await q.getAndSend(switchExpr, s => s.selector, sel => this.visit(sel, q));
+        await q.getAndSend(switchExpr, s => s.cases, block => this.visit(block, q));
+        await q.getAndSend(switchExpr, s => (0, rpc_1.asRef)(s.type), type => this.visitType(type, q));
+        return switchExpr;
+    }
+    async visitSynchronized(syncStmt, q) {
+        await q.getAndSend(syncStmt, s => s.lock, lock => this.visit(lock, q));
+        await q.getAndSend(syncStmt, s => s.body, body => this.visit(body, q));
+        return syncStmt;
+    }
+    async visitTernary(ternary, q) {
+        await q.getAndSend(ternary, t => t.condition, cond => this.visit(cond, q));
+        await q.getAndSend(ternary, t => t.truePart, truePart => this.visitLeftPadded(truePart, q));
+        await q.getAndSend(ternary, t => t.falsePart, falsePart => this.visitLeftPadded(falsePart, q));
+        await q.getAndSend(ternary, t => (0, rpc_1.asRef)(t.type), type => this.visitType(type, q));
+        return ternary;
+    }
+    async visitThrow(throwStmt, q) {
+        await q.getAndSend(throwStmt, t => t.exception, exc => this.visit(exc, q));
+        return throwStmt;
+    }
+    async visitTry(tryStmt, q) {
+        await q.getAndSend(tryStmt, t => t.resources, res => this.visitContainer(res, q));
+        await q.getAndSend(tryStmt, t => t.body, body => this.visit(body, q));
+        await q.getAndSendList(tryStmt, t => t.catches, catch_ => catch_.id, catch_ => this.visit(catch_, q));
+        await q.getAndSend(tryStmt, t => t.finally, fin => this.visitLeftPadded(fin, q));
+        return tryStmt;
+    }
+    async visitTryResource(resource, q) {
+        await q.getAndSend(resource, r => r.variableDeclarations, variable => this.visit(variable, q));
+        await q.getAndSend(resource, r => r.terminatedWithSemicolon);
+        return resource;
+    }
+    async visitTryCatch(aCatch, q) {
+        await q.getAndSend(aCatch, c => c.parameter, param => this.visit(param, q));
+        await q.getAndSend(aCatch, c => c.body, body => this.visit(body, q));
+        return aCatch;
+    }
+    async visitTypeCast(typeCast, q) {
+        await q.getAndSend(typeCast, t => t.class, clazz => this.visit(clazz, q));
+        await q.getAndSend(typeCast, t => t.expression, expr => this.visit(expr, q));
+        return typeCast;
+    }
+    async visitTypeParameter(typeParam, q) {
+        await q.getAndSendList(typeParam, t => t.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSendList(typeParam, t => t.modifiers, mod => mod.id, mod => this.visit(mod, q));
+        await q.getAndSend(typeParam, t => t.name, name => this.visit(name, q));
+        await q.getAndSend(typeParam, t => t.bounds, bounds => this.visitContainer(bounds, q));
+        return typeParam;
+    }
+    async visitTypeParameters(typeParams, q) {
+        await q.getAndSendList(typeParams, a => a.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSendList(typeParams, t => t.typeParameters, p => p.element.id, params => this.visitRightPadded(params, q));
+        return typeParams;
+    }
+    async visitUnary(unary, q) {
+        await q.getAndSend(unary, u => u.operator, op => this.visitLeftPadded(op, q));
+        await q.getAndSend(unary, u => u.expression, expr => this.visit(expr, q));
+        await q.getAndSend(unary, u => (0, rpc_1.asRef)(u.type), type => this.visitType(type, q));
+        return unary;
+    }
+    async visitVariable(variable, q) {
+        await q.getAndSend(variable, v => v.name, name => this.visit(name, q));
+        await q.getAndSendList(variable, v => v.dimensionsAfterName, d => JSON.stringify(d.element), dims => this.visitLeftPadded(dims, q));
+        await q.getAndSend(variable, v => v.initializer, init => this.visitLeftPadded(init, q));
+        await q.getAndSend(variable, v => (0, rpc_1.asRef)(v.variableType), type => this.visitType(type, q));
+        return variable;
+    }
+    async visitWhileLoop(whileLoop, q) {
+        await q.getAndSend(whileLoop, w => w.condition, cond => this.visit(cond, q));
+        await q.getAndSend(whileLoop, w => w.body, body => this.visitRightPadded(body, q));
+        return whileLoop;
+    }
+    async visitWildcard(wildcard, q) {
+        await q.getAndSend(wildcard, w => w.bound, b => this.visitLeftPadded(b, q));
+        await q.getAndSend(wildcard, w => w.boundedType, type => this.visit(type, q));
+        return wildcard;
+    }
+    async visitYield(yieldExpr, q) {
+        await q.getAndSend(yieldExpr, y => y.implicit);
+        await q.getAndSend(yieldExpr, y => y.value, value => this.visit(value, q));
+        return yieldExpr;
+    }
+    async visitUnknown(unknown, q) {
+        await q.getAndSend(unknown, u => u.source, source => this.visit(source, q));
+        return unknown;
+    }
+    async visitUnknownSource(source, q) {
+        await q.getAndSend(source, s => s.text);
+        return source;
+    }
+    async visitCompilationUnit(cu, q) {
+        await q.getAndSend(cu, c => c.sourcePath);
+        await q.getAndSend(cu, c => c.charsetName);
+        await q.getAndSend(cu, c => c.charsetBomMarked);
+        await q.getAndSend(cu, c => c.checksum);
+        await q.getAndSend(cu, c => c.fileAttributes);
+        await q.getAndSend(cu, c => c.packageDeclaration, pkg => this.visitRightPadded(pkg, q));
+        await q.getAndSendList(cu, c => c.imports, imp => imp.element.id, imp => this.visitRightPadded(imp, q));
+        await q.getAndSendList(cu, c => c.classes, cls => cls.id, cls => this.visit(cls, q));
+        await q.getAndSend(cu, c => c.eof, space => this.visitSpace(space, q));
+        return cu;
+    }
+    async visitPackage(pkg, q) {
+        await q.getAndSend(pkg, p => p.expression, expr => this.visit(expr, q));
+        await q.getAndSendList(pkg, p => p.annotations, annot => annot.id, annot => this.visit(annot, q));
+        return pkg;
+    }
+    async visitClassDeclaration(cls, q) {
+        await q.getAndSendList(cls, c => c.leadingAnnotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSendList(cls, c => c.modifiers, mod => mod.id, mod => this.visit(mod, q));
+        await q.getAndSend(cls, c => c.classKind, kind => this.visit(kind, q));
+        await q.getAndSend(cls, c => c.name, name => this.visit(name, q));
+        await q.getAndSend(cls, c => c.typeParameters, params => this.visitContainer(params, q));
+        await q.getAndSend(cls, c => c.primaryConstructor, cons => this.visitContainer(cons, q));
+        await q.getAndSend(cls, c => c.extends, ext => this.visitLeftPadded(ext, q));
+        await q.getAndSend(cls, c => c.implements, impl => this.visitContainer(impl, q));
+        await q.getAndSend(cls, c => c.permitting, perm => this.visitContainer(perm, q));
+        await q.getAndSend(cls, c => c.body, body => this.visit(body, q));
+        return cls;
+    }
+    async visitClassDeclarationKind(kind, q) {
+        await q.getAndSendList(kind, k => k.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(kind, k => k.type);
+        return kind;
+    }
+    async visitBlock(block, q) {
+        await q.getAndSend(block, b => b.static, s => this.visitRightPadded(s, q));
+        await q.getAndSendList(block, b => b.statements, stmt => stmt.element.id, stmt => this.visitRightPadded(stmt, q));
+        await q.getAndSend(block, b => b.end, space => this.visitSpace(space, q));
+        return block;
+    }
+    async visitMethodDeclaration(method, q) {
+        await q.getAndSendList(method, m => m.leadingAnnotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSendList(method, m => m.modifiers, mod => mod.id, mod => this.visit(mod, q));
+        await q.getAndSend(method, m => m.typeParameters, params => this.visit(params, q));
+        await q.getAndSend(method, m => m.returnTypeExpression, type => this.visit(type, q));
+        await q.getAndSendList(method, m => m.nameAnnotations, a => a.id, name => this.visit(name, q));
+        await q.getAndSend(method, m => m.name, name => this.visit(name, q));
+        await q.getAndSend(method, m => m.parameters, params => this.visitContainer(params, q));
+        await q.getAndSend(method, m => m.throws, throws => this.visitContainer(throws, q));
+        await q.getAndSend(method, m => m.body, body => this.visit(body, q));
+        await q.getAndSend(method, m => m.defaultValue, def => this.visitLeftPadded(def, q));
+        await q.getAndSend(method, m => (0, rpc_1.asRef)(m.methodType), type => this.visitType(type, q));
+        return method;
+    }
+    async visitVariableDeclarations(varDecls, q) {
+        await q.getAndSendList(varDecls, v => v.leadingAnnotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSendList(varDecls, v => v.modifiers, mod => mod.id, mod => this.visit(mod, q));
+        await q.getAndSend(varDecls, v => v.typeExpression, type => this.visit(type, q));
+        await q.getAndSend(varDecls, v => v.varargs, space => this.visitSpace(space, q));
+        await q.getAndSendList(varDecls, v => v.variables, variable => variable.element.id, variable => this.visitRightPadded(variable, q));
+        return varDecls;
+    }
+    async visitIdentifier(ident, q) {
+        await q.getAndSendList(ident, id => id.annotations, annot => annot.id, annot => this.visit(annot, q));
+        await q.getAndSend(ident, id => id.simpleName);
+        await q.getAndSend(ident, id => (0, rpc_1.asRef)(id.type), type => this.visitType(type, q));
+        await q.getAndSend(ident, id => (0, rpc_1.asRef)(id.fieldType), type => this.visitType(type, q));
+        return ident;
+    }
+    async visitSpace(space, q) {
+        await q.getAndSendList(space, s => s.comments, c => {
+            if (c.kind === tree_1.J.Kind.TextComment) {
+                return c.text + c.suffix;
             }
-            yield q.getAndSend(left, l => l.markers);
-            return left;
-        });
-    }
-    visitRightPadded(right, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((0, tree_2.isTree)(right.element)) {
-                yield q.getAndSend(right, r => r.element, elem => this.visit(elem, q));
+            throw new Error(`Unexpected comment type ${c.kind}`);
+        }, async (c) => {
+            if (c.kind === tree_1.J.Kind.TextComment) {
+                const tc = c;
+                await q.getAndSend(tc, c2 => c2.multiline);
+                await q.getAndSend(tc, c2 => c2.text);
             }
             else {
-                yield q.getAndSend(right, r => r.element);
+                throw new Error(`Unexpected comment type ${c.kind}`);
             }
-            yield q.getAndSend(right, r => r.after, space => this.visitSpace(space, q));
-            yield q.getAndSend(right, r => r.markers);
-            return right;
+            await q.getAndSend(c, c2 => c2.suffix);
+            await q.getAndSend(c, c2 => c2.markers);
         });
+        await q.getAndSend(space, s => s.whitespace);
+        return space;
     }
-    visitContainer(container, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield q.getAndSend(container, c => c.before, space => this.visitSpace(space, q));
-            yield q.getAndSendList(container, c => c.elements, elem => elem.element.id, elem => this.visitRightPadded(elem, q));
-            yield q.getAndSend(container, c => c.markers);
-            return container;
-        });
+    async visitLeftPadded(left, q) {
+        await q.getAndSend(left, l => l.before, space => this.visitSpace(space, q));
+        if ((0, tree_2.isTree)(left.element)) {
+            await q.getAndSend(left, l => l.element, elem => this.visit(elem, q));
+        }
+        else if ((0, tree_1.isSpace)(left.element)) {
+            await q.getAndSend(left, l => l.element, space => this.visitSpace(space, q));
+        }
+        else {
+            await q.getAndSend(left, l => l.element);
+        }
+        await q.getAndSend(left, l => l.markers);
+        return left;
     }
-    visitType(javaType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!javaType) {
-                return undefined;
-            }
-            return yield this.typeVisitor.visit(javaType, q);
-        });
+    async visitRightPadded(right, q) {
+        if ((0, tree_2.isTree)(right.element)) {
+            await q.getAndSend(right, r => r.element, elem => this.visit(elem, q));
+        }
+        else {
+            await q.getAndSend(right, r => r.element);
+        }
+        await q.getAndSend(right, r => r.after, space => this.visitSpace(space, q));
+        await q.getAndSend(right, r => r.markers);
+        return right;
+    }
+    async visitContainer(container, q) {
+        await q.getAndSend(container, c => c.before, space => this.visitSpace(space, q));
+        await q.getAndSendList(container, c => c.elements, elem => elem.element.id, elem => this.visitRightPadded(elem, q));
+        await q.getAndSend(container, c => c.markers);
+        return container;
+    }
+    async visitType(javaType, q) {
+        if (!javaType) {
+            return undefined;
+        }
+        return await this.typeVisitor.visit(javaType, q);
     }
 }
 exports.JavaSender = JavaSender;
@@ -941,808 +734,654 @@ class JavaReceiver extends visitor_1.JavaVisitor {
         super(...arguments);
         this.typeVisitor = new TypeReceiver();
     }
-    preVisit(j, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const updates = {
-                    id: yield q.receive(j.id),
-                    prefix: yield q.receive(j.prefix, space => this.visitSpace(space, q)),
-                    markers: yield q.receive(j.markers)
-                };
-                return (0, util_1.updateIfChanged)(j, updates);
-            }
-            catch (e) {
-                throw e;
-            }
-        });
-    }
-    visitAnnotatedType(annotatedType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(annotatedType.annotations, annot => this.visit(annot, q)),
-                typeExpression: yield q.receive(annotatedType.typeExpression, type => this.visit(type, q))
-            };
-            return (0, util_1.updateIfChanged)(annotatedType, updates);
-        });
-    }
-    visitAnnotation(annotation, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotationType: yield q.receive(annotation.annotationType, type => this.visit(type, q)),
-                arguments: yield q.receive(annotation.arguments, args => this.visitContainer(args, q))
-            };
-            return (0, util_1.updateIfChanged)(annotation, updates);
-        });
-    }
-    visitArrayAccess(arrayAccess, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                indexed: yield q.receive(arrayAccess.indexed, indexed => this.visit(indexed, q)),
-                dimension: yield q.receive(arrayAccess.dimension, dim => this.visit(dim, q))
-            };
-            return (0, util_1.updateIfChanged)(arrayAccess, updates);
-        });
-    }
-    visitArrayDimension(dimension, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                index: yield q.receive(dimension.index, idx => this.visitRightPadded(idx, q))
-            };
-            return (0, util_1.updateIfChanged)(dimension, updates);
-        });
-    }
-    visitArrayType(arrayType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                elementType: yield q.receive(arrayType.elementType, type => this.visit(type, q)),
-                annotations: yield q.receiveListDefined(arrayType.annotations || [], annot => this.visit(annot, q)),
-                dimension: yield q.receive(arrayType.dimension, d => this.visitLeftPadded(d, q)),
-                type: yield q.receive(arrayType.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(arrayType, updates);
-        });
-    }
-    visitAssert(assert, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                condition: yield q.receive(assert.condition, cond => this.visit(cond, q)),
-                detail: yield q.receive(assert.detail, detail => this.visitOptionalLeftPadded(detail, q))
-            };
-            return (0, util_1.updateIfChanged)(assert, updates);
-        });
-    }
-    visitAssignment(assignment, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                variable: yield q.receive(assignment.variable, variable => this.visit(variable, q)),
-                assignment: yield q.receive(assignment.assignment, assign => this.visitLeftPadded(assign, q)),
-                type: yield q.receive(assignment.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(assignment, updates);
-        });
-    }
-    visitAssignmentOperation(assignOp, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                variable: yield q.receive(assignOp.variable, variable => this.visit(variable, q)),
-                operator: yield q.receive(assignOp.operator, op => this.visitLeftPadded(op, q)),
-                assignment: yield q.receive(assignOp.assignment, assign => this.visit(assign, q)),
-                type: yield q.receive(assignOp.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(assignOp, updates);
-        });
-    }
-    visitBinary(binary, q) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async preVisit(j, q) {
+        try {
             const updates = {
-                left: yield q.receive(binary.left, left => this.visit(left, q)),
-                operator: yield q.receive(binary.operator, op => this.visitLeftPadded(op, q)),
-                right: yield q.receive(binary.right, right => this.visit(right, q)),
-                type: yield q.receive(binary.type, type => this.visitType(type, q))
+                id: await q.receive(j.id),
+                prefix: await q.receive(j.prefix, space => this.visitSpace(space, q)),
+                markers: await q.receive(j.markers)
             };
-            return (0, util_1.updateIfChanged)(binary, updates);
-        });
+            return (0, util_1.updateIfChanged)(j, updates);
+        }
+        catch (e) {
+            throw e;
+        }
     }
-    visitBreak(breakStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                label: yield q.receive(breakStmt.label, label => this.visit(label, q))
-            };
-            return (0, util_1.updateIfChanged)(breakStmt, updates);
-        });
-    }
-    visitCase(caseStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                type: yield q.receive(caseStmt.type),
-                caseLabels: yield q.receive(caseStmt.caseLabels, labels => this.visitContainer(labels, q)),
-                statements: yield q.receive(caseStmt.statements, stmts => this.visitContainer(stmts, q)),
-                body: yield q.receive(caseStmt.body, body => this.visitRightPadded(body, q)),
-                guard: yield q.receive(caseStmt.guard, guard => this.visit(guard, q))
-            };
-            return (0, util_1.updateIfChanged)(caseStmt, updates);
-        });
-    }
-    visitContinue(continueStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                label: yield q.receive(continueStmt.label, label => this.visit(label, q))
-            };
-            return (0, util_1.updateIfChanged)(continueStmt, updates);
-        });
-    }
-    visitControlParentheses(controlParens, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                tree: yield q.receive(controlParens.tree, tree => this.visitRightPadded(tree, q))
-            };
-            return (0, util_1.updateIfChanged)(controlParens, updates);
-        });
-    }
-    visitDeconstructionPattern(pattern, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                deconstructor: yield q.receive(pattern.deconstructor, deconstructor => this.visit(deconstructor, q)),
-                nested: yield q.receive(pattern.nested, nested => this.visitContainer(nested, q)),
-                type: yield q.receive(pattern.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(pattern, updates);
-        });
-    }
-    visitDoWhileLoop(doWhile, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                body: yield q.receive(doWhile.body, body => this.visitOptionalRightPadded(body, q)),
-                whileCondition: yield q.receive(doWhile.whileCondition, cond => this.visitLeftPadded(cond, q))
-            };
-            return (0, util_1.updateIfChanged)(doWhile, updates);
-        });
-    }
-    visitEmpty(empty) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // no additional properties to receive
-            return empty;
-        });
-    }
-    visitEnumValueSet(enumValueSet, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                enums: yield q.receiveListDefined(enumValueSet.enums, enumValue => this.visitRightPadded(enumValue, q)),
-                terminatedWithSemicolon: yield q.receive(enumValueSet.terminatedWithSemicolon)
-            };
-            return (0, util_1.updateIfChanged)(enumValueSet, updates);
-        });
-    }
-    visitEnumValue(enumValue, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(enumValue.annotations, annot => this.visit(annot, q)),
-                name: yield q.receive(enumValue.name, name => this.visit(name, q)),
-                initializer: yield q.receive(enumValue.initializer, init => this.visit(init, q))
-            };
-            return (0, util_1.updateIfChanged)(enumValue, updates);
-        });
-    }
-    visitErroneous(erroneous, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                text: yield q.receive(erroneous.text)
-            };
-            return (0, util_1.updateIfChanged)(erroneous, updates);
-        });
-    }
-    visitFieldAccess(fieldAccess, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                target: yield q.receive(fieldAccess.target, target => this.visit(target, q)),
-                name: yield q.receive(fieldAccess.name, name => this.visitLeftPadded(name, q)),
-                type: yield q.receive(fieldAccess.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(fieldAccess, updates);
-        });
-    }
-    visitForEachLoop(forEachLoop, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                control: yield q.receive(forEachLoop.control, c => this.visit(c, q)),
-                body: yield q.receive(forEachLoop.body, body => this.visitRightPadded(body, q))
-            };
-            return (0, util_1.updateIfChanged)(forEachLoop, updates);
-        });
-    }
-    visitForEachLoopControl(control, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                variable: yield q.receive(control.variable, variable => this.visitRightPadded(variable, q)),
-                iterable: yield q.receive(control.iterable, expr => this.visitRightPadded(expr, q))
-            };
-            return (0, util_1.updateIfChanged)(control, updates);
-        });
-    }
-    visitForLoop(forLoop, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                control: yield q.receive(forLoop.control, c => this.visit(c, q)),
-                body: yield q.receive(forLoop.body, body => this.visitRightPadded(body, q))
-            };
-            return (0, util_1.updateIfChanged)(forLoop, updates);
-        });
-    }
-    visitForLoopControl(control, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                init: yield q.receiveListDefined(control.init, init => this.visitRightPadded(init, q)),
-                condition: yield q.receive(control.condition, cond => this.visitRightPadded(cond, q)),
-                update: yield q.receiveListDefined(control.update, update => this.visitRightPadded(update, q))
-            };
-            return (0, util_1.updateIfChanged)(control, updates);
-        });
-    }
-    visitIf(ifStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                ifCondition: yield q.receive(ifStmt.ifCondition, cond => this.visit(cond, q)),
-                thenPart: yield q.receive(ifStmt.thenPart, thenPart => this.visitRightPadded(thenPart, q)),
-                elsePart: yield q.receive(ifStmt.elsePart, elsePart => this.visit(elsePart, q))
-            };
-            return (0, util_1.updateIfChanged)(ifStmt, updates);
-        });
-    }
-    visitElse(ifElse, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                body: yield q.receive(ifElse.body, body => this.visitRightPadded(body, q))
-            };
-            return (0, util_1.updateIfChanged)(ifElse, updates);
-        });
-    }
-    visitImport(importStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                static: yield q.receive(importStmt.static, s => this.visitLeftPadded(s, q)),
-                qualid: yield q.receive(importStmt.qualid, qualid => this.visit(qualid, q)),
-                alias: yield q.receive(importStmt.alias, alias => this.visitLeftPadded(alias, q))
-            };
-            return (0, util_1.updateIfChanged)(importStmt, updates);
-        });
-    }
-    visitInstanceOf(instanceOf, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                expression: yield q.receive(instanceOf.expression, expr => this.visitRightPadded(expr, q)),
-                class: yield q.receive(instanceOf.class, clazz => this.visit(clazz, q)),
-                pattern: yield q.receive(instanceOf.pattern, pattern => this.visit(pattern, q)),
-                type: yield q.receive(instanceOf.type, type => this.visitType(type, q)),
-                modifier: yield q.receive(instanceOf.modifier, mod => this.visit(mod, q))
-            };
-            return (0, util_1.updateIfChanged)(instanceOf, updates);
-        });
-    }
-    visitIntersectionType(intersectionType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                bounds: yield q.receive(intersectionType.bounds, bounds => this.visitContainer(bounds, q))
-            };
-            return (0, util_1.updateIfChanged)(intersectionType, updates);
-        });
-    }
-    visitLabel(label, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                label: yield q.receive(label.label, lbl => this.visitRightPadded(lbl, q)),
-                statement: yield q.receive(label.statement, stmt => this.visit(stmt, q))
-            };
-            return (0, util_1.updateIfChanged)(label, updates);
-        });
-    }
-    visitLambda(lambda, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                parameters: yield q.receive(lambda.parameters, params => this.visit(params, q)),
-                arrow: yield q.receive(lambda.arrow, arrow => this.visitSpace(arrow, q)),
-                body: yield q.receive(lambda.body, body => this.visit(body, q)),
-                type: yield q.receive(lambda.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(lambda, updates);
-        });
-    }
-    visitLambdaParameters(params, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                parenthesized: yield q.receive(params.parenthesized),
-                parameters: yield q.receiveListDefined(params.parameters, param => this.visitRightPadded(param, q))
-            };
-            return (0, util_1.updateIfChanged)(params, updates);
-        });
-    }
-    visitLiteral(literal, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                value: yield q.receive(literal.value),
-                valueSource: yield q.receive(literal.valueSource),
-                unicodeEscapes: yield q.receiveList(literal.unicodeEscapes),
-                type: yield q.receive(literal.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(literal, updates);
-        });
-    }
-    visitMemberReference(memberRef, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                containing: yield q.receive(memberRef.containing, container => this.visitRightPadded(container, q)),
-                typeParameters: yield q.receive(memberRef.typeParameters, typeParams => this.visitContainer(typeParams, q)),
-                reference: yield q.receive(memberRef.reference, ref => this.visitLeftPadded(ref, q)),
-                type: yield q.receive(memberRef.type, type => this.visitType(type, q)),
-                methodType: yield q.receive(memberRef.methodType, type => this.visitType(type, q)),
-                variableType: yield q.receive(memberRef.variableType, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(memberRef, updates);
-        });
-    }
-    visitMethodInvocation(methodInvoc, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                select: yield q.receive(methodInvoc.select, select => this.visitRightPadded(select, q)),
-                typeParameters: yield q.receive(methodInvoc.typeParameters, typeParams => this.visitContainer(typeParams, q)),
-                name: yield q.receive(methodInvoc.name, name => this.visit(name, q)),
-                arguments: yield q.receive(methodInvoc.arguments, args => this.visitContainer(args, q)),
-                methodType: yield q.receive(methodInvoc.methodType, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(methodInvoc, updates);
-        });
-    }
-    visitModifier(modifier, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                keyword: yield q.receive(modifier.keyword),
-                type: yield q.receive(modifier.type),
-                annotations: yield q.receiveListDefined(modifier.annotations, annot => this.visit(annot, q))
-            };
-            return (0, util_1.updateIfChanged)(modifier, updates);
-        });
-    }
-    visitMultiCatch(multiCatch, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                alternatives: yield q.receiveListDefined(multiCatch.alternatives, alt => this.visitRightPadded(alt, q))
-            };
-            return (0, util_1.updateIfChanged)(multiCatch, updates);
-        });
-    }
-    visitNewArray(newArray, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                typeExpression: yield q.receive(newArray.typeExpression, type => this.visit(type, q)),
-                dimensions: yield q.receiveListDefined(newArray.dimensions, dim => this.visit(dim, q)),
-                initializer: yield q.receive(newArray.initializer, init => this.visitContainer(init, q)),
-                type: yield q.receive(newArray.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(newArray, updates);
-        });
-    }
-    visitNewClass(newClass, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                enclosing: yield q.receive(newClass.enclosing, encl => this.visitRightPadded(encl, q)),
-                new: yield q.receive(newClass.new, new_ => this.visitSpace(new_, q)),
-                class: yield q.receive(newClass.class, clazz => this.visit(clazz, q)),
-                arguments: yield q.receive(newClass.arguments, args => this.visitContainer(args, q)),
-                body: yield q.receive(newClass.body, body => this.visit(body, q)),
-                constructorType: yield q.receive(newClass.constructorType, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(newClass, updates);
-        });
-    }
-    visitNullableType(nullableType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(nullableType.annotations, annot => this.visit(annot, q)),
-                typeTree: yield q.receive(nullableType.typeTree, type => this.visitRightPadded(type, q))
-            };
-            return (0, util_1.updateIfChanged)(nullableType, updates);
-        });
-    }
-    visitParameterizedType(paramType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                class: yield q.receive(paramType.class, clazz => this.visit(clazz, q)),
-                typeParameters: yield q.receive(paramType.typeParameters, params => this.visitContainer(params, q)),
-                type: yield q.receive(paramType.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(paramType, updates);
-        });
-    }
-    visitParentheses(parentheses, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                tree: yield q.receive(parentheses.tree, tree => this.visitRightPadded(tree, q))
-            };
-            return (0, util_1.updateIfChanged)(parentheses, updates);
-        });
-    }
-    visitParenthesizedTypeTree(parenthesizedType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(parenthesizedType.annotations, annot => this.visit(annot, q)),
-                parenthesizedType: yield q.receive(parenthesizedType.parenthesizedType, tree => this.visit(tree, q))
-            };
-            return (0, util_1.updateIfChanged)(parenthesizedType, updates);
-        });
-    }
-    visitPrimitive(primitive, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                type: yield q.receive(primitive.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(primitive, updates);
-        });
-    }
-    visitSwitch(switchStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                selector: yield q.receive(switchStmt.selector, selector => this.visit(selector, q)),
-                cases: yield q.receive(switchStmt.cases, cases => this.visit(cases, q))
-            };
-            return (0, util_1.updateIfChanged)(switchStmt, updates);
-        });
-    }
-    visitSwitchExpression(switchExpr, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                selector: yield q.receive(switchExpr.selector, selector => this.visit(selector, q)),
-                cases: yield q.receive(switchExpr.cases, cases => this.visit(cases, q)),
-                type: yield q.receive(switchExpr.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(switchExpr, updates);
-        });
-    }
-    visitTernary(ternary, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                condition: yield q.receive(ternary.condition, cond => this.visit(cond, q)),
-                truePart: yield q.receive(ternary.truePart, truePart => this.visitLeftPadded(truePart, q)),
-                falsePart: yield q.receive(ternary.falsePart, falsePart => this.visitLeftPadded(falsePart, q)),
-                type: yield q.receive(ternary.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(ternary, updates);
-        });
-    }
-    visitThrow(throwStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                exception: yield q.receive(throwStmt.exception, exception => this.visit(exception, q))
-            };
-            return (0, util_1.updateIfChanged)(throwStmt, updates);
-        });
-    }
-    visitTry(tryStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                resources: yield q.receive(tryStmt.resources, resources => this.visitContainer(resources, q)),
-                body: yield q.receive(tryStmt.body, body => this.visit(body, q)),
-                catches: yield q.receiveListDefined(tryStmt.catches, catchBlock => this.visit(catchBlock, q)),
-                finally: yield q.receive(tryStmt.finally, finallyBlock => this.visitOptionalLeftPadded(finallyBlock, q))
-            };
-            return (0, util_1.updateIfChanged)(tryStmt, updates);
-        });
-    }
-    visitTryResource(resource, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                variableDeclarations: yield q.receive(resource.variableDeclarations, variables => this.visit(variables, q)),
-                terminatedWithSemicolon: yield q.receive(resource.terminatedWithSemicolon)
-            };
-            return (0, util_1.updateIfChanged)(resource, updates);
-        });
-    }
-    visitTryCatch(tryCatch, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                parameter: yield q.receive(tryCatch.parameter, param => this.visit(param, q)),
-                body: yield q.receive(tryCatch.body, body => this.visit(body, q))
-            };
-            return (0, util_1.updateIfChanged)(tryCatch, updates);
-        });
-    }
-    visitUnary(unary, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                operator: yield q.receive(unary.operator, op => this.visitLeftPadded(op, q)),
-                expression: yield q.receive(unary.expression, expr => this.visit(expr, q)),
-                type: yield q.receive(unary.type, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(unary, updates);
-        });
-    }
-    visitUnknown(unknown, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                source: yield q.receive(unknown.source, source => this.visit(source, q))
-            };
-            return (0, util_1.updateIfChanged)(unknown, updates);
-        });
-    }
-    visitUnknownSource(unknownSource, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                text: yield q.receive(unknownSource.text)
-            };
-            return (0, util_1.updateIfChanged)(unknownSource, updates);
-        });
-    }
-    visitVariable(variable, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                name: yield q.receive(variable.name, name => this.visit(name, q)),
-                dimensionsAfterName: yield q.receiveListDefined(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, q)),
-                initializer: yield q.receive(variable.initializer, init => this.visitOptionalLeftPadded(init, q)),
-                variableType: yield q.receive(variable.variableType, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(variable, updates);
-        });
-    }
-    visitYield(yieldStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                implicit: yield q.receive(yieldStmt.implicit),
-                value: yield q.receive(yieldStmt.value, value => this.visit(value, q))
-            };
-            return (0, util_1.updateIfChanged)(yieldStmt, updates);
-        });
-    }
-    visitTypeParameters(typeParams, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(typeParams.annotations, annot => this.visit(annot, q)),
-                typeParameters: yield q.receiveListDefined(typeParams.typeParameters, param => this.visitRightPadded(param, q))
-            };
-            return (0, util_1.updateIfChanged)(typeParams, updates);
-        });
-    }
-    visitReturn(returnStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                expression: yield q.receive(returnStmt.expression, expr => this.visit(expr, q))
-            };
-            return (0, util_1.updateIfChanged)(returnStmt, updates);
-        });
-    }
-    visitSynchronized(synchronizedStmt, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                lock: yield q.receive(synchronizedStmt.lock, lock => this.visit(lock, q)),
-                body: yield q.receive(synchronizedStmt.body, body => this.visit(body, q))
-            };
-            return (0, util_1.updateIfChanged)(synchronizedStmt, updates);
-        });
-    }
-    visitTypeCast(typeCast, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                class: yield q.receive(typeCast.class, typeExpr => this.visit(typeExpr, q)),
-                expression: yield q.receive(typeCast.expression, expr => this.visit(expr, q))
-            };
-            return (0, util_1.updateIfChanged)(typeCast, updates);
-        });
-    }
-    visitTypeParameter(typeParameter, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(typeParameter.annotations, annot => this.visit(annot, q)),
-                modifiers: yield q.receiveListDefined(typeParameter.modifiers, annot => this.visit(annot, q)),
-                name: yield q.receive(typeParameter.name, name => this.visit(name, q)),
-                bounds: yield q.receive(typeParameter.bounds, bounds => this.visitContainer(bounds, q))
-            };
-            return (0, util_1.updateIfChanged)(typeParameter, updates);
-        });
-    }
-    visitWhileLoop(whileLoop, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                condition: yield q.receive(whileLoop.condition, cond => this.visit(cond, q)),
-                body: yield q.receive(whileLoop.body, body => this.visitOptionalRightPadded(body, q))
-            };
-            return (0, util_1.updateIfChanged)(whileLoop, updates);
-        });
-    }
-    visitWildcard(wildcard, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                bound: yield q.receive(wildcard.bound, bound => this.visitLeftPadded(bound, q)),
-                boundedType: yield q.receive(wildcard.boundedType, type => this.visit(type, q))
-            };
-            return (0, util_1.updateIfChanged)(wildcard, updates);
-        });
-    }
-    visitCompilationUnit(cu, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                sourcePath: yield q.receive(cu.sourcePath),
-                charsetName: yield q.receive(cu.charsetName),
-                charsetBomMarked: yield q.receive(cu.charsetBomMarked),
-                checksum: yield q.receive(cu.checksum),
-                fileAttributes: yield q.receive(cu.fileAttributes),
-                packageDeclaration: yield q.receive(cu.packageDeclaration, pkg => this.visitRightPadded(pkg, q)),
-                imports: yield q.receiveListDefined(cu.imports, imp => this.visitRightPadded(imp, q)),
-                classes: yield q.receiveListDefined(cu.classes, cls => this.visit(cls, q)),
-                eof: yield q.receive(cu.eof, space => this.visitSpace(space, q))
-            };
-            return (0, util_1.updateIfChanged)(cu, updates);
-        });
-    }
-    visitPackage(pkg, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                expression: yield q.receive(pkg.expression, expr => this.visit(expr, q)),
-                annotations: yield q.receiveListDefined(pkg.annotations, annot => this.visit(annot, q))
-            };
-            return (0, util_1.updateIfChanged)(pkg, updates);
-        });
-    }
-    visitClassDeclaration(cls, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                leadingAnnotations: yield q.receiveListDefined(cls.leadingAnnotations, annot => this.visit(annot, q)),
-                modifiers: yield q.receiveListDefined(cls.modifiers, mod => this.visit(mod, q)),
-                classKind: yield q.receive(cls.classKind, kind => this.visit(kind, q)),
-                name: yield q.receive(cls.name, name => this.visit(name, q)),
-                typeParameters: yield q.receive(cls.typeParameters, params => this.visitContainer(params, q)),
-                primaryConstructor: yield q.receive(cls.primaryConstructor, cons => this.visitContainer(cons, q)),
-                extends: yield q.receive(cls.extends, ext => this.visitLeftPadded(ext, q)),
-                implements: yield q.receive(cls.implements, impl => this.visitContainer(impl, q)),
-                permitting: yield q.receive(cls.permitting, perm => this.visitContainer(perm, q)),
-                body: yield q.receive(cls.body, body => this.visit(body, q))
-            };
-            return (0, util_1.updateIfChanged)(cls, updates);
-        });
-    }
-    visitClassDeclarationKind(kind, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(kind.annotations, annot => this.visit(annot, q)),
-                type: yield q.receive(kind.type)
-            };
-            return (0, util_1.updateIfChanged)(kind, updates);
-        });
-    }
-    visitBlock(block, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                static: yield q.receive(block.static, s => this.visitRightPadded(s, q)),
-                statements: yield q.receiveListDefined(block.statements, stmt => this.visitRightPadded(stmt, q)),
-                end: yield q.receive(block.end, space => this.visitSpace(space, q))
-            };
-            return (0, util_1.updateIfChanged)(block, updates);
-        });
-    }
-    visitMethodDeclaration(method, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                leadingAnnotations: yield q.receiveListDefined(method.leadingAnnotations, annot => this.visit(annot, q)),
-                modifiers: yield q.receiveListDefined(method.modifiers, mod => this.visit(mod, q)),
-                typeParameters: yield q.receive(method.typeParameters, params => this.visit(params, q)),
-                returnTypeExpression: yield q.receive(method.returnTypeExpression, type => this.visit(type, q)),
-                nameAnnotations: (yield q.receiveList(method.nameAnnotations, name => this.visit(name, q))),
-                name: yield q.receive(method.name, name => this.visit(name, q)),
-                parameters: yield q.receive(method.parameters, params => this.visitContainer(params, q)),
-                throws: yield q.receive(method.throws, throws => this.visitContainer(throws, q)),
-                body: yield q.receive(method.body, body => this.visit(body, q)),
-                defaultValue: yield q.receive(method.defaultValue, def => this.visitLeftPadded(def, q)),
-                methodType: yield q.receive(method.methodType, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(method, updates);
-        });
-    }
-    visitVariableDeclarations(varDecls, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                leadingAnnotations: yield q.receiveListDefined(varDecls.leadingAnnotations, annot => this.visit(annot, q)),
-                modifiers: yield q.receiveListDefined(varDecls.modifiers, mod => this.visit(mod, q)),
-                typeExpression: yield q.receive(varDecls.typeExpression, type => this.visit(type, q)),
-                varargs: yield q.receive(varDecls.varargs, space => this.visitSpace(space, q)),
-                variables: yield q.receiveListDefined(varDecls.variables, variable => this.visitRightPadded(variable, q))
-            };
-            return (0, util_1.updateIfChanged)(varDecls, updates);
-        });
-    }
-    visitIdentifier(ident, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                annotations: yield q.receiveListDefined(ident.annotations, annot => this.visit(annot, q)),
-                simpleName: yield q.receive(ident.simpleName),
-                type: yield q.receive(ident.type, type => this.visitType(type, q)),
-                fieldType: yield q.receive(ident.fieldType, type => this.visitType(type, q))
-            };
-            return (0, util_1.updateIfChanged)(ident, updates);
-        });
-    }
-    visitSpace(space, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                comments: yield q.receiveListDefined(space.comments, (c) => __awaiter(this, void 0, void 0, function* () {
-                    if (c.kind === tree_1.J.Kind.TextComment) {
-                        const tc = c;
-                        const commentUpdates = {
-                            multiline: yield q.receive(tc.multiline),
-                            text: yield q.receive(tc.text),
-                            suffix: yield q.receive(c.suffix),
-                            markers: yield q.receive(c.markers)
-                        };
-                        return (0, util_1.updateIfChanged)(tc, commentUpdates);
-                    }
-                    else {
-                        throw new Error(`Unexpected comment type ${c.kind}`);
-                    }
-                })),
-                whitespace: yield q.receive(space.whitespace)
-            };
-            return (0, util_1.updateIfChanged)(space, updates);
-        });
-    }
-    visitLeftPadded(left, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!left) {
-                throw new Error("TreeDataReceiveQueue should have instantiated an empty left padding");
-            }
-            const updates = {
-                before: yield q.receive(left.before, space => this.visitSpace(space, q)),
-                element: yield q.receive(left.element, elem => {
-                    if ((0, tree_1.isSpace)(elem)) {
-                        return this.visitSpace(elem, q);
-                    }
-                    else if (typeof elem === 'object' && elem.kind) {
-                        // FIXME find a better way to check if it is a `Tree`
-                        return this.visit(elem, q);
-                    }
-                    return elem;
-                }),
-                markers: yield q.receive(left.markers)
-            };
-            return (0, util_1.updateIfChanged)(left, updates);
-        });
-    }
-    visitRightPadded(right, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!right) {
-                throw new Error("TreeDataReceiveQueue should have instantiated an empty right padding");
-            }
-            const updates = {
-                element: yield q.receive(right.element, elem => {
-                    if ((0, tree_1.isSpace)(elem)) {
-                        return this.visitSpace(elem, q);
-                    }
-                    else if (typeof elem === 'object' && elem.kind) {
-                        // FIXME find a better way to check if it is a `Tree`
-                        return this.visit(elem, q);
-                    }
-                    return elem;
-                }),
-                after: yield q.receive(right.after, space => this.visitSpace(space, q)),
-                markers: yield q.receive(right.markers)
-            };
-            return (0, util_1.updateIfChanged)(right, updates);
-        });
-    }
-    visitContainer(container, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const updates = {
-                before: yield q.receive(container.before, space => this.visitSpace(space, q)),
-                elements: yield q.receiveListDefined(container.elements, elem => this.visitRightPadded(elem, q)),
-                markers: yield q.receive(container.markers)
-            };
-            return (0, util_1.updateIfChanged)(container, updates);
-        });
-    }
-    visitType(javaType, q) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!javaType) {
-                return undefined;
-            }
-            else if (javaType.kind === type_1.Type.Kind.Unknown) {
-                return type_1.Type.unknownType;
-            }
-            return yield this.typeVisitor.visit(javaType, q);
-        });
+    async visitAnnotatedType(annotatedType, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(annotatedType.annotations, annot => this.visit(annot, q)),
+            typeExpression: await q.receive(annotatedType.typeExpression, type => this.visit(type, q))
+        };
+        return (0, util_1.updateIfChanged)(annotatedType, updates);
+    }
+    async visitAnnotation(annotation, q) {
+        const updates = {
+            annotationType: await q.receive(annotation.annotationType, type => this.visit(type, q)),
+            arguments: await q.receive(annotation.arguments, args => this.visitContainer(args, q))
+        };
+        return (0, util_1.updateIfChanged)(annotation, updates);
+    }
+    async visitArrayAccess(arrayAccess, q) {
+        const updates = {
+            indexed: await q.receive(arrayAccess.indexed, indexed => this.visit(indexed, q)),
+            dimension: await q.receive(arrayAccess.dimension, dim => this.visit(dim, q))
+        };
+        return (0, util_1.updateIfChanged)(arrayAccess, updates);
+    }
+    async visitArrayDimension(dimension, q) {
+        const updates = {
+            index: await q.receive(dimension.index, idx => this.visitRightPadded(idx, q))
+        };
+        return (0, util_1.updateIfChanged)(dimension, updates);
+    }
+    async visitArrayType(arrayType, q) {
+        const updates = {
+            elementType: await q.receive(arrayType.elementType, type => this.visit(type, q)),
+            annotations: await q.receiveListDefined(arrayType.annotations || [], annot => this.visit(annot, q)),
+            dimension: await q.receive(arrayType.dimension, d => this.visitLeftPadded(d, q)),
+            type: await q.receive(arrayType.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(arrayType, updates);
+    }
+    async visitAssert(assert, q) {
+        const updates = {
+            condition: await q.receive(assert.condition, cond => this.visit(cond, q)),
+            detail: await q.receive(assert.detail, detail => this.visitOptionalLeftPadded(detail, q))
+        };
+        return (0, util_1.updateIfChanged)(assert, updates);
+    }
+    async visitAssignment(assignment, q) {
+        const updates = {
+            variable: await q.receive(assignment.variable, variable => this.visit(variable, q)),
+            assignment: await q.receive(assignment.assignment, assign => this.visitLeftPadded(assign, q)),
+            type: await q.receive(assignment.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(assignment, updates);
+    }
+    async visitAssignmentOperation(assignOp, q) {
+        const updates = {
+            variable: await q.receive(assignOp.variable, variable => this.visit(variable, q)),
+            operator: await q.receive(assignOp.operator, op => this.visitLeftPadded(op, q)),
+            assignment: await q.receive(assignOp.assignment, assign => this.visit(assign, q)),
+            type: await q.receive(assignOp.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(assignOp, updates);
+    }
+    async visitBinary(binary, q) {
+        const updates = {
+            left: await q.receive(binary.left, left => this.visit(left, q)),
+            operator: await q.receive(binary.operator, op => this.visitLeftPadded(op, q)),
+            right: await q.receive(binary.right, right => this.visit(right, q)),
+            type: await q.receive(binary.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(binary, updates);
+    }
+    async visitBreak(breakStmt, q) {
+        const updates = {
+            label: await q.receive(breakStmt.label, label => this.visit(label, q))
+        };
+        return (0, util_1.updateIfChanged)(breakStmt, updates);
+    }
+    async visitCase(caseStmt, q) {
+        const updates = {
+            type: await q.receive(caseStmt.type),
+            caseLabels: await q.receive(caseStmt.caseLabels, labels => this.visitContainer(labels, q)),
+            statements: await q.receive(caseStmt.statements, stmts => this.visitContainer(stmts, q)),
+            body: await q.receive(caseStmt.body, body => this.visitRightPadded(body, q)),
+            guard: await q.receive(caseStmt.guard, guard => this.visit(guard, q))
+        };
+        return (0, util_1.updateIfChanged)(caseStmt, updates);
+    }
+    async visitContinue(continueStmt, q) {
+        const updates = {
+            label: await q.receive(continueStmt.label, label => this.visit(label, q))
+        };
+        return (0, util_1.updateIfChanged)(continueStmt, updates);
+    }
+    async visitControlParentheses(controlParens, q) {
+        const updates = {
+            tree: await q.receive(controlParens.tree, tree => this.visitRightPadded(tree, q))
+        };
+        return (0, util_1.updateIfChanged)(controlParens, updates);
+    }
+    async visitDeconstructionPattern(pattern, q) {
+        const updates = {
+            deconstructor: await q.receive(pattern.deconstructor, deconstructor => this.visit(deconstructor, q)),
+            nested: await q.receive(pattern.nested, nested => this.visitContainer(nested, q)),
+            type: await q.receive(pattern.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(pattern, updates);
+    }
+    async visitDoWhileLoop(doWhile, q) {
+        const updates = {
+            body: await q.receive(doWhile.body, body => this.visitOptionalRightPadded(body, q)),
+            whileCondition: await q.receive(doWhile.whileCondition, cond => this.visitLeftPadded(cond, q))
+        };
+        return (0, util_1.updateIfChanged)(doWhile, updates);
+    }
+    async visitEmpty(empty) {
+        // no additional properties to receive
+        return empty;
+    }
+    async visitEnumValueSet(enumValueSet, q) {
+        const updates = {
+            enums: await q.receiveListDefined(enumValueSet.enums, enumValue => this.visitRightPadded(enumValue, q)),
+            terminatedWithSemicolon: await q.receive(enumValueSet.terminatedWithSemicolon)
+        };
+        return (0, util_1.updateIfChanged)(enumValueSet, updates);
+    }
+    async visitEnumValue(enumValue, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(enumValue.annotations, annot => this.visit(annot, q)),
+            name: await q.receive(enumValue.name, name => this.visit(name, q)),
+            initializer: await q.receive(enumValue.initializer, init => this.visit(init, q))
+        };
+        return (0, util_1.updateIfChanged)(enumValue, updates);
+    }
+    async visitErroneous(erroneous, q) {
+        const updates = {
+            text: await q.receive(erroneous.text)
+        };
+        return (0, util_1.updateIfChanged)(erroneous, updates);
+    }
+    async visitFieldAccess(fieldAccess, q) {
+        const updates = {
+            target: await q.receive(fieldAccess.target, target => this.visit(target, q)),
+            name: await q.receive(fieldAccess.name, name => this.visitLeftPadded(name, q)),
+            type: await q.receive(fieldAccess.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(fieldAccess, updates);
+    }
+    async visitForEachLoop(forEachLoop, q) {
+        const updates = {
+            control: await q.receive(forEachLoop.control, c => this.visit(c, q)),
+            body: await q.receive(forEachLoop.body, body => this.visitRightPadded(body, q))
+        };
+        return (0, util_1.updateIfChanged)(forEachLoop, updates);
+    }
+    async visitForEachLoopControl(control, q) {
+        const updates = {
+            variable: await q.receive(control.variable, variable => this.visitRightPadded(variable, q)),
+            iterable: await q.receive(control.iterable, expr => this.visitRightPadded(expr, q))
+        };
+        return (0, util_1.updateIfChanged)(control, updates);
+    }
+    async visitForLoop(forLoop, q) {
+        const updates = {
+            control: await q.receive(forLoop.control, c => this.visit(c, q)),
+            body: await q.receive(forLoop.body, body => this.visitRightPadded(body, q))
+        };
+        return (0, util_1.updateIfChanged)(forLoop, updates);
+    }
+    async visitForLoopControl(control, q) {
+        const updates = {
+            init: await q.receiveListDefined(control.init, init => this.visitRightPadded(init, q)),
+            condition: await q.receive(control.condition, cond => this.visitRightPadded(cond, q)),
+            update: await q.receiveListDefined(control.update, update => this.visitRightPadded(update, q))
+        };
+        return (0, util_1.updateIfChanged)(control, updates);
+    }
+    async visitIf(ifStmt, q) {
+        const updates = {
+            ifCondition: await q.receive(ifStmt.ifCondition, cond => this.visit(cond, q)),
+            thenPart: await q.receive(ifStmt.thenPart, thenPart => this.visitRightPadded(thenPart, q)),
+            elsePart: await q.receive(ifStmt.elsePart, elsePart => this.visit(elsePart, q))
+        };
+        return (0, util_1.updateIfChanged)(ifStmt, updates);
+    }
+    async visitElse(ifElse, q) {
+        const updates = {
+            body: await q.receive(ifElse.body, body => this.visitRightPadded(body, q))
+        };
+        return (0, util_1.updateIfChanged)(ifElse, updates);
+    }
+    async visitImport(importStmt, q) {
+        const updates = {
+            static: await q.receive(importStmt.static, s => this.visitLeftPadded(s, q)),
+            qualid: await q.receive(importStmt.qualid, qualid => this.visit(qualid, q)),
+            alias: await q.receive(importStmt.alias, alias => this.visitLeftPadded(alias, q))
+        };
+        return (0, util_1.updateIfChanged)(importStmt, updates);
+    }
+    async visitInstanceOf(instanceOf, q) {
+        const updates = {
+            expression: await q.receive(instanceOf.expression, expr => this.visitRightPadded(expr, q)),
+            class: await q.receive(instanceOf.class, clazz => this.visit(clazz, q)),
+            pattern: await q.receive(instanceOf.pattern, pattern => this.visit(pattern, q)),
+            type: await q.receive(instanceOf.type, type => this.visitType(type, q)),
+            modifier: await q.receive(instanceOf.modifier, mod => this.visit(mod, q))
+        };
+        return (0, util_1.updateIfChanged)(instanceOf, updates);
+    }
+    async visitIntersectionType(intersectionType, q) {
+        const updates = {
+            bounds: await q.receive(intersectionType.bounds, bounds => this.visitContainer(bounds, q))
+        };
+        return (0, util_1.updateIfChanged)(intersectionType, updates);
+    }
+    async visitLabel(label, q) {
+        const updates = {
+            label: await q.receive(label.label, lbl => this.visitRightPadded(lbl, q)),
+            statement: await q.receive(label.statement, stmt => this.visit(stmt, q))
+        };
+        return (0, util_1.updateIfChanged)(label, updates);
+    }
+    async visitLambda(lambda, q) {
+        const updates = {
+            parameters: await q.receive(lambda.parameters, params => this.visit(params, q)),
+            arrow: await q.receive(lambda.arrow, arrow => this.visitSpace(arrow, q)),
+            body: await q.receive(lambda.body, body => this.visit(body, q)),
+            type: await q.receive(lambda.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(lambda, updates);
+    }
+    async visitLambdaParameters(params, q) {
+        const updates = {
+            parenthesized: await q.receive(params.parenthesized),
+            parameters: await q.receiveListDefined(params.parameters, param => this.visitRightPadded(param, q))
+        };
+        return (0, util_1.updateIfChanged)(params, updates);
+    }
+    async visitLiteral(literal, q) {
+        const updates = {
+            value: await q.receive(literal.value),
+            valueSource: await q.receive(literal.valueSource),
+            unicodeEscapes: await q.receiveList(literal.unicodeEscapes),
+            type: await q.receive(literal.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(literal, updates);
+    }
+    async visitMemberReference(memberRef, q) {
+        const updates = {
+            containing: await q.receive(memberRef.containing, container => this.visitRightPadded(container, q)),
+            typeParameters: await q.receive(memberRef.typeParameters, typeParams => this.visitContainer(typeParams, q)),
+            reference: await q.receive(memberRef.reference, ref => this.visitLeftPadded(ref, q)),
+            type: await q.receive(memberRef.type, type => this.visitType(type, q)),
+            methodType: await q.receive(memberRef.methodType, type => this.visitType(type, q)),
+            variableType: await q.receive(memberRef.variableType, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(memberRef, updates);
+    }
+    async visitMethodInvocation(methodInvoc, q) {
+        const updates = {
+            select: await q.receive(methodInvoc.select, select => this.visitRightPadded(select, q)),
+            typeParameters: await q.receive(methodInvoc.typeParameters, typeParams => this.visitContainer(typeParams, q)),
+            name: await q.receive(methodInvoc.name, name => this.visit(name, q)),
+            arguments: await q.receive(methodInvoc.arguments, args => this.visitContainer(args, q)),
+            methodType: await q.receive(methodInvoc.methodType, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(methodInvoc, updates);
+    }
+    async visitModifier(modifier, q) {
+        const updates = {
+            keyword: await q.receive(modifier.keyword),
+            type: await q.receive(modifier.type),
+            annotations: await q.receiveListDefined(modifier.annotations, annot => this.visit(annot, q))
+        };
+        return (0, util_1.updateIfChanged)(modifier, updates);
+    }
+    async visitMultiCatch(multiCatch, q) {
+        const updates = {
+            alternatives: await q.receiveListDefined(multiCatch.alternatives, alt => this.visitRightPadded(alt, q))
+        };
+        return (0, util_1.updateIfChanged)(multiCatch, updates);
+    }
+    async visitNewArray(newArray, q) {
+        const updates = {
+            typeExpression: await q.receive(newArray.typeExpression, type => this.visit(type, q)),
+            dimensions: await q.receiveListDefined(newArray.dimensions, dim => this.visit(dim, q)),
+            initializer: await q.receive(newArray.initializer, init => this.visitContainer(init, q)),
+            type: await q.receive(newArray.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(newArray, updates);
+    }
+    async visitNewClass(newClass, q) {
+        const updates = {
+            enclosing: await q.receive(newClass.enclosing, encl => this.visitRightPadded(encl, q)),
+            new: await q.receive(newClass.new, new_ => this.visitSpace(new_, q)),
+            class: await q.receive(newClass.class, clazz => this.visit(clazz, q)),
+            arguments: await q.receive(newClass.arguments, args => this.visitContainer(args, q)),
+            body: await q.receive(newClass.body, body => this.visit(body, q)),
+            constructorType: await q.receive(newClass.constructorType, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(newClass, updates);
+    }
+    async visitNullableType(nullableType, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(nullableType.annotations, annot => this.visit(annot, q)),
+            typeTree: await q.receive(nullableType.typeTree, type => this.visitRightPadded(type, q))
+        };
+        return (0, util_1.updateIfChanged)(nullableType, updates);
+    }
+    async visitParameterizedType(paramType, q) {
+        const updates = {
+            class: await q.receive(paramType.class, clazz => this.visit(clazz, q)),
+            typeParameters: await q.receive(paramType.typeParameters, params => this.visitContainer(params, q)),
+            type: await q.receive(paramType.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(paramType, updates);
+    }
+    async visitParentheses(parentheses, q) {
+        const updates = {
+            tree: await q.receive(parentheses.tree, tree => this.visitRightPadded(tree, q))
+        };
+        return (0, util_1.updateIfChanged)(parentheses, updates);
+    }
+    async visitParenthesizedTypeTree(parenthesizedType, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(parenthesizedType.annotations, annot => this.visit(annot, q)),
+            parenthesizedType: await q.receive(parenthesizedType.parenthesizedType, tree => this.visit(tree, q))
+        };
+        return (0, util_1.updateIfChanged)(parenthesizedType, updates);
+    }
+    async visitPrimitive(primitive, q) {
+        const updates = {
+            type: await q.receive(primitive.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(primitive, updates);
+    }
+    async visitSwitch(switchStmt, q) {
+        const updates = {
+            selector: await q.receive(switchStmt.selector, selector => this.visit(selector, q)),
+            cases: await q.receive(switchStmt.cases, cases => this.visit(cases, q))
+        };
+        return (0, util_1.updateIfChanged)(switchStmt, updates);
+    }
+    async visitSwitchExpression(switchExpr, q) {
+        const updates = {
+            selector: await q.receive(switchExpr.selector, selector => this.visit(selector, q)),
+            cases: await q.receive(switchExpr.cases, cases => this.visit(cases, q)),
+            type: await q.receive(switchExpr.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(switchExpr, updates);
+    }
+    async visitTernary(ternary, q) {
+        const updates = {
+            condition: await q.receive(ternary.condition, cond => this.visit(cond, q)),
+            truePart: await q.receive(ternary.truePart, truePart => this.visitLeftPadded(truePart, q)),
+            falsePart: await q.receive(ternary.falsePart, falsePart => this.visitLeftPadded(falsePart, q)),
+            type: await q.receive(ternary.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(ternary, updates);
+    }
+    async visitThrow(throwStmt, q) {
+        const updates = {
+            exception: await q.receive(throwStmt.exception, exception => this.visit(exception, q))
+        };
+        return (0, util_1.updateIfChanged)(throwStmt, updates);
+    }
+    async visitTry(tryStmt, q) {
+        const updates = {
+            resources: await q.receive(tryStmt.resources, resources => this.visitContainer(resources, q)),
+            body: await q.receive(tryStmt.body, body => this.visit(body, q)),
+            catches: await q.receiveListDefined(tryStmt.catches, catchBlock => this.visit(catchBlock, q)),
+            finally: await q.receive(tryStmt.finally, finallyBlock => this.visitOptionalLeftPadded(finallyBlock, q))
+        };
+        return (0, util_1.updateIfChanged)(tryStmt, updates);
+    }
+    async visitTryResource(resource, q) {
+        const updates = {
+            variableDeclarations: await q.receive(resource.variableDeclarations, variables => this.visit(variables, q)),
+            terminatedWithSemicolon: await q.receive(resource.terminatedWithSemicolon)
+        };
+        return (0, util_1.updateIfChanged)(resource, updates);
+    }
+    async visitTryCatch(tryCatch, q) {
+        const updates = {
+            parameter: await q.receive(tryCatch.parameter, param => this.visit(param, q)),
+            body: await q.receive(tryCatch.body, body => this.visit(body, q))
+        };
+        return (0, util_1.updateIfChanged)(tryCatch, updates);
+    }
+    async visitUnary(unary, q) {
+        const updates = {
+            operator: await q.receive(unary.operator, op => this.visitLeftPadded(op, q)),
+            expression: await q.receive(unary.expression, expr => this.visit(expr, q)),
+            type: await q.receive(unary.type, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(unary, updates);
+    }
+    async visitUnknown(unknown, q) {
+        const updates = {
+            source: await q.receive(unknown.source, source => this.visit(source, q))
+        };
+        return (0, util_1.updateIfChanged)(unknown, updates);
+    }
+    async visitUnknownSource(unknownSource, q) {
+        const updates = {
+            text: await q.receive(unknownSource.text)
+        };
+        return (0, util_1.updateIfChanged)(unknownSource, updates);
+    }
+    async visitVariable(variable, q) {
+        const updates = {
+            name: await q.receive(variable.name, name => this.visit(name, q)),
+            dimensionsAfterName: await q.receiveListDefined(variable.dimensionsAfterName, dim => this.visitLeftPadded(dim, q)),
+            initializer: await q.receive(variable.initializer, init => this.visitOptionalLeftPadded(init, q)),
+            variableType: await q.receive(variable.variableType, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(variable, updates);
+    }
+    async visitYield(yieldStmt, q) {
+        const updates = {
+            implicit: await q.receive(yieldStmt.implicit),
+            value: await q.receive(yieldStmt.value, value => this.visit(value, q))
+        };
+        return (0, util_1.updateIfChanged)(yieldStmt, updates);
+    }
+    async visitTypeParameters(typeParams, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(typeParams.annotations, annot => this.visit(annot, q)),
+            typeParameters: await q.receiveListDefined(typeParams.typeParameters, param => this.visitRightPadded(param, q))
+        };
+        return (0, util_1.updateIfChanged)(typeParams, updates);
+    }
+    async visitReturn(returnStmt, q) {
+        const updates = {
+            expression: await q.receive(returnStmt.expression, expr => this.visit(expr, q))
+        };
+        return (0, util_1.updateIfChanged)(returnStmt, updates);
+    }
+    async visitSynchronized(synchronizedStmt, q) {
+        const updates = {
+            lock: await q.receive(synchronizedStmt.lock, lock => this.visit(lock, q)),
+            body: await q.receive(synchronizedStmt.body, body => this.visit(body, q))
+        };
+        return (0, util_1.updateIfChanged)(synchronizedStmt, updates);
+    }
+    async visitTypeCast(typeCast, q) {
+        const updates = {
+            class: await q.receive(typeCast.class, typeExpr => this.visit(typeExpr, q)),
+            expression: await q.receive(typeCast.expression, expr => this.visit(expr, q))
+        };
+        return (0, util_1.updateIfChanged)(typeCast, updates);
+    }
+    async visitTypeParameter(typeParameter, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(typeParameter.annotations, annot => this.visit(annot, q)),
+            modifiers: await q.receiveListDefined(typeParameter.modifiers, annot => this.visit(annot, q)),
+            name: await q.receive(typeParameter.name, name => this.visit(name, q)),
+            bounds: await q.receive(typeParameter.bounds, bounds => this.visitContainer(bounds, q))
+        };
+        return (0, util_1.updateIfChanged)(typeParameter, updates);
+    }
+    async visitWhileLoop(whileLoop, q) {
+        const updates = {
+            condition: await q.receive(whileLoop.condition, cond => this.visit(cond, q)),
+            body: await q.receive(whileLoop.body, body => this.visitOptionalRightPadded(body, q))
+        };
+        return (0, util_1.updateIfChanged)(whileLoop, updates);
+    }
+    async visitWildcard(wildcard, q) {
+        const updates = {
+            bound: await q.receive(wildcard.bound, bound => this.visitLeftPadded(bound, q)),
+            boundedType: await q.receive(wildcard.boundedType, type => this.visit(type, q))
+        };
+        return (0, util_1.updateIfChanged)(wildcard, updates);
+    }
+    async visitCompilationUnit(cu, q) {
+        const updates = {
+            sourcePath: await q.receive(cu.sourcePath),
+            charsetName: await q.receive(cu.charsetName),
+            charsetBomMarked: await q.receive(cu.charsetBomMarked),
+            checksum: await q.receive(cu.checksum),
+            fileAttributes: await q.receive(cu.fileAttributes),
+            packageDeclaration: await q.receive(cu.packageDeclaration, pkg => this.visitRightPadded(pkg, q)),
+            imports: await q.receiveListDefined(cu.imports, imp => this.visitRightPadded(imp, q)),
+            classes: await q.receiveListDefined(cu.classes, cls => this.visit(cls, q)),
+            eof: await q.receive(cu.eof, space => this.visitSpace(space, q))
+        };
+        return (0, util_1.updateIfChanged)(cu, updates);
+    }
+    async visitPackage(pkg, q) {
+        const updates = {
+            expression: await q.receive(pkg.expression, expr => this.visit(expr, q)),
+            annotations: await q.receiveListDefined(pkg.annotations, annot => this.visit(annot, q))
+        };
+        return (0, util_1.updateIfChanged)(pkg, updates);
+    }
+    async visitClassDeclaration(cls, q) {
+        const updates = {
+            leadingAnnotations: await q.receiveListDefined(cls.leadingAnnotations, annot => this.visit(annot, q)),
+            modifiers: await q.receiveListDefined(cls.modifiers, mod => this.visit(mod, q)),
+            classKind: await q.receive(cls.classKind, kind => this.visit(kind, q)),
+            name: await q.receive(cls.name, name => this.visit(name, q)),
+            typeParameters: await q.receive(cls.typeParameters, params => this.visitContainer(params, q)),
+            primaryConstructor: await q.receive(cls.primaryConstructor, cons => this.visitContainer(cons, q)),
+            extends: await q.receive(cls.extends, ext => this.visitLeftPadded(ext, q)),
+            implements: await q.receive(cls.implements, impl => this.visitContainer(impl, q)),
+            permitting: await q.receive(cls.permitting, perm => this.visitContainer(perm, q)),
+            body: await q.receive(cls.body, body => this.visit(body, q))
+        };
+        return (0, util_1.updateIfChanged)(cls, updates);
+    }
+    async visitClassDeclarationKind(kind, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(kind.annotations, annot => this.visit(annot, q)),
+            type: await q.receive(kind.type)
+        };
+        return (0, util_1.updateIfChanged)(kind, updates);
+    }
+    async visitBlock(block, q) {
+        const updates = {
+            static: await q.receive(block.static, s => this.visitRightPadded(s, q)),
+            statements: await q.receiveListDefined(block.statements, stmt => this.visitRightPadded(stmt, q)),
+            end: await q.receive(block.end, space => this.visitSpace(space, q))
+        };
+        return (0, util_1.updateIfChanged)(block, updates);
+    }
+    async visitMethodDeclaration(method, q) {
+        const updates = {
+            leadingAnnotations: await q.receiveListDefined(method.leadingAnnotations, annot => this.visit(annot, q)),
+            modifiers: await q.receiveListDefined(method.modifiers, mod => this.visit(mod, q)),
+            typeParameters: await q.receive(method.typeParameters, params => this.visit(params, q)),
+            returnTypeExpression: await q.receive(method.returnTypeExpression, type => this.visit(type, q)),
+            nameAnnotations: (await q.receiveList(method.nameAnnotations, name => this.visit(name, q))),
+            name: await q.receive(method.name, name => this.visit(name, q)),
+            parameters: await q.receive(method.parameters, params => this.visitContainer(params, q)),
+            throws: await q.receive(method.throws, throws => this.visitContainer(throws, q)),
+            body: await q.receive(method.body, body => this.visit(body, q)),
+            defaultValue: await q.receive(method.defaultValue, def => this.visitLeftPadded(def, q)),
+            methodType: await q.receive(method.methodType, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(method, updates);
+    }
+    async visitVariableDeclarations(varDecls, q) {
+        const updates = {
+            leadingAnnotations: await q.receiveListDefined(varDecls.leadingAnnotations, annot => this.visit(annot, q)),
+            modifiers: await q.receiveListDefined(varDecls.modifiers, mod => this.visit(mod, q)),
+            typeExpression: await q.receive(varDecls.typeExpression, type => this.visit(type, q)),
+            varargs: await q.receive(varDecls.varargs, space => this.visitSpace(space, q)),
+            variables: await q.receiveListDefined(varDecls.variables, variable => this.visitRightPadded(variable, q))
+        };
+        return (0, util_1.updateIfChanged)(varDecls, updates);
+    }
+    async visitIdentifier(ident, q) {
+        const updates = {
+            annotations: await q.receiveListDefined(ident.annotations, annot => this.visit(annot, q)),
+            simpleName: await q.receive(ident.simpleName),
+            type: await q.receive(ident.type, type => this.visitType(type, q)),
+            fieldType: await q.receive(ident.fieldType, type => this.visitType(type, q))
+        };
+        return (0, util_1.updateIfChanged)(ident, updates);
+    }
+    async visitSpace(space, q) {
+        const updates = {
+            comments: await q.receiveListDefined(space.comments, async (c) => {
+                if (c.kind === tree_1.J.Kind.TextComment) {
+                    const tc = c;
+                    const commentUpdates = {
+                        multiline: await q.receive(tc.multiline),
+                        text: await q.receive(tc.text),
+                        suffix: await q.receive(c.suffix),
+                        markers: await q.receive(c.markers)
+                    };
+                    return (0, util_1.updateIfChanged)(tc, commentUpdates);
+                }
+                else {
+                    throw new Error(`Unexpected comment type ${c.kind}`);
+                }
+            }),
+            whitespace: await q.receive(space.whitespace)
+        };
+        return (0, util_1.updateIfChanged)(space, updates);
+    }
+    async visitLeftPadded(left, q) {
+        if (!left) {
+            throw new Error("TreeDataReceiveQueue should have instantiated an empty left padding");
+        }
+        const updates = {
+            before: await q.receive(left.before, space => this.visitSpace(space, q)),
+            element: await q.receive(left.element, elem => {
+                if ((0, tree_1.isSpace)(elem)) {
+                    return this.visitSpace(elem, q);
+                }
+                else if (typeof elem === 'object' && elem.kind) {
+                    // FIXME find a better way to check if it is a `Tree`
+                    return this.visit(elem, q);
+                }
+                return elem;
+            }),
+            markers: await q.receive(left.markers)
+        };
+        return (0, util_1.updateIfChanged)(left, updates);
+    }
+    async visitRightPadded(right, q) {
+        if (!right) {
+            throw new Error("TreeDataReceiveQueue should have instantiated an empty right padding");
+        }
+        const updates = {
+            element: await q.receive(right.element, elem => {
+                if ((0, tree_1.isSpace)(elem)) {
+                    return this.visitSpace(elem, q);
+                }
+                else if (typeof elem === 'object' && elem.kind) {
+                    // FIXME find a better way to check if it is a `Tree`
+                    return this.visit(elem, q);
+                }
+                return elem;
+            }),
+            after: await q.receive(right.after, space => this.visitSpace(space, q)),
+            markers: await q.receive(right.markers)
+        };
+        return (0, util_1.updateIfChanged)(right, updates);
+    }
+    async visitContainer(container, q) {
+        const updates = {
+            before: await q.receive(container.before, space => this.visitSpace(space, q)),
+            elements: await q.receiveListDefined(container.elements, elem => this.visitRightPadded(elem, q)),
+            markers: await q.receive(container.markers)
+        };
+        return (0, util_1.updateIfChanged)(container, updates);
+    }
+    async visitType(javaType, q) {
+        if (!javaType) {
+            return undefined;
+        }
+        else if (javaType.kind === type_1.Type.Kind.Unknown) {
+            return type_1.Type.unknownType;
+        }
+        return await this.typeVisitor.visit(javaType, q);
     }
 }
 exports.JavaReceiver = JavaReceiver;
@@ -1755,71 +1394,51 @@ function registerJLanguageCodecs(sourceFileType, receiver, sender, extendedKinds
     for (const kind of kinds) {
         if (kind === tree_1.J.Kind.Space) {
             rpc_1.RpcCodecs.registerCodec(kind, {
-                rpcReceive(before, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return (yield receiver.visitSpace(before, q));
-                    });
+                async rpcReceive(before, q) {
+                    return (await receiver.visitSpace(before, q));
                 },
-                rpcSend(after, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        yield sender.visitSpace(after, q);
-                    });
+                async rpcSend(after, q) {
+                    await sender.visitSpace(after, q);
                 }
             }, sourceFileType);
         }
         else if (kind === tree_1.J.Kind.RightPadded) {
             rpc_1.RpcCodecs.registerCodec(kind, {
-                rpcReceive(before, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return (yield receiver.visitRightPadded(before, q));
-                    });
+                async rpcReceive(before, q) {
+                    return (await receiver.visitRightPadded(before, q));
                 },
-                rpcSend(after, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        yield sender.visitRightPadded(after, q);
-                    });
+                async rpcSend(after, q) {
+                    await sender.visitRightPadded(after, q);
                 }
             }, sourceFileType);
         }
         else if (kind === tree_1.J.Kind.LeftPadded) {
             rpc_1.RpcCodecs.registerCodec(kind, {
-                rpcReceive(before, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return (yield receiver.visitLeftPadded(before, q));
-                    });
+                async rpcReceive(before, q) {
+                    return (await receiver.visitLeftPadded(before, q));
                 },
-                rpcSend(after, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        yield sender.visitLeftPadded(after, q);
-                    });
+                async rpcSend(after, q) {
+                    await sender.visitLeftPadded(after, q);
                 }
             }, sourceFileType);
         }
         else if (kind === tree_1.J.Kind.Container) {
             rpc_1.RpcCodecs.registerCodec(kind, {
-                rpcReceive(before, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return (yield receiver.visitContainer(before, q));
-                    });
+                async rpcReceive(before, q) {
+                    return (await receiver.visitContainer(before, q));
                 },
-                rpcSend(after, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        yield sender.visitContainer(after, q);
-                    });
+                async rpcSend(after, q) {
+                    await sender.visitContainer(after, q);
                 }
             }, sourceFileType);
         }
         else {
             rpc_1.RpcCodecs.registerCodec(kind, {
-                rpcReceive(before, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        return (yield receiver.visit(before, q));
-                    });
+                async rpcReceive(before, q) {
+                    return (await receiver.visit(before, q));
                 },
-                rpcSend(after, q) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        yield sender.visit(after, q);
-                    });
+                async rpcSend(after, q) {
+                    await sender.visit(after, q);
                 }
             }, sourceFileType);
         }