@openrewrite/rewrite 8.92.16 → 8.92.17

package/src/javascript/print.ts

@@ -21,7 +21,7 @@ import {PrintOutputCapture, TreePrinters} from "../print";
 import {Cursor, isTree, Tree} from "../tree";
 import {Comment, emptySpace, J, Statement, TextComment, TrailingComma, TypedTree} from "../java";
 import {findMarker, Marker, Markers} from "../markers";
-import {DelegatedYield, FunctionDeclaration, Generator, NonNullAssertion, Optional} from "./markers";
+import {Computed, DelegatedYield, FunctionDeclaration, Generator, NonNullAssertion, Optional} from "./markers";
 
 export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
@@ -140,10 +140,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     override async visitJsxAttribute(attribute: JSX.Attribute, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(attribute, p);
         await this.visit(attribute.key, p);
-        if (attribute.value) {
-            p.append("=");
-            await this.visit(attribute.value.element, p);
-        }
+        await this.visitLeftPaddedLocal("=", attribute.value, p);
         await this.afterSyntax(attribute, p);
         return attribute;
     }
@@ -308,6 +305,10 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         p.append("catch");
         if (aCatch.parameter.tree.element.variables.length > 0) {
             await this.visit(aCatch.parameter, p);
+        } else {
+            this.beforeSyntaxMarkers(aCatch.parameter.markers, p);
+            await this.markersOnly(aCatch.parameter.tree.element, p);
+            await this.afterSyntax(aCatch.parameter, p);
         }
         await this.visit(aCatch.body, p);
         await this.afterSyntax(aCatch, p);
@@ -662,15 +663,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         if (functionType.constructorType.element) {
             await this.visitLeftPaddedLocal("new", functionType.constructorType, p);
         }
-        const typeParameters = functionType.typeParameters;
-        if (typeParameters) {
-            await this.visitNodes(typeParameters.annotations, p);
-            await this.visitSpace(typeParameters.prefix, p);
-            await this.visitMarkers(typeParameters.markers, p);
-            p.append("<");
-            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-            p.append(">");
-        }
+        await this.printTypeParameters(functionType.typeParameters, p);
 
         await this.visitContainerLocal("(", functionType.parameters, ",", ")", p);
         await this.visitLeftPaddedLocal("=>", functionType.returnType, p);
@@ -679,9 +672,9 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         return functionType;
     }
 
-    override async visitClassDeclaration(classDecl: J.ClassDeclaration, p: PrintOutputCapture): Promise<J | undefined> {
+    override async visitClassDeclarationKind(classKind: J.ClassDeclaration.Kind, p: PrintOutputCapture): Promise<J | undefined> {
         let kind = "";
-        switch (classDecl.classKind.type) {
+        switch (classKind.type) {
             case J.ClassDeclaration.Kind.Type.Class:
                 kind = "class";
                 break;
@@ -699,15 +692,21 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
                 break;
         }
 
+        await this.visitNodes(classKind.annotations, p);
+        await this.beforeSyntax(classKind, p);
+        p.append(kind);
+        await this.afterSyntax(classKind, p);
+        return classKind;
+    }
+
+    override async visitClassDeclaration(classDecl: J.ClassDeclaration, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(classDecl, p);
         await this.visitSpace(emptySpace, p);
         await this.visitNodes(classDecl.leadingAnnotations, p);
         for (const m of classDecl.modifiers) {
             await this.visitModifier(m, p);
         }
-        await this.visitNodes(classDecl.classKind.annotations, p);
-        await this.visitSpace(classDecl.classKind.prefix, p);
-        p.append(kind);
+        await this.visitClassDeclarationKind(classDecl.classKind, p);
         await this.visit(classDecl.name, p);
         classDecl.typeParameters && await this.visitContainerLocal("<", classDecl.typeParameters, ",", ">", p);
         classDecl.primaryConstructor && await this.visitContainerLocal("(", classDecl.primaryConstructor, ",", ")", p);
@@ -727,6 +726,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         for (const m of method.modifiers) {
             await this.visitModifier(m, p);
         }
+        await this.visitNodes(method.nameAnnotations, p);
 
         let m;
         if ((m = findMarker<FunctionDeclaration>(method, JS.Markers.FunctionDeclaration))) {
@@ -742,15 +742,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
         await this.visit(method.name, p);
 
-        const typeParameters = method.typeParameters;
-        if (typeParameters) {
-            await this.visitNodes(typeParameters.annotations, p);
-            await this.visitSpace(typeParameters.prefix, p);
-            await this.visitMarkers(typeParameters.markers, p);
-            p.append("<");
-            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-            p.append(">");
-        }
+        await this.printTypeParameters(method.typeParameters, p);
 
         await this.visitContainerLocal("(", method.parameters, ",", ")", p);
 
@@ -779,15 +771,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
         await this.visit(method.name, p);
 
-        const typeParameters = method.typeParameters;
-        if (typeParameters) {
-            await this.visitNodes(typeParameters.annotations, p);
-            await this.visitSpace(typeParameters.prefix, p);
-            await this.visitMarkers(typeParameters.markers, p);
-            p.append("<");
-            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-            p.append(">");
-        }
+        await this.printTypeParameters(method.typeParameters, p);
 
         await this.visitContainerLocal("(", method.parameters, ",", ")", p);
         if (method.returnTypeExpression) {
@@ -839,12 +823,16 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
             if (!(constraintType.element.kind === J.Kind.Empty)) {
                 p.append("extends");
                 await this.visitRightPadded(constraintType, p);
+            } else {
+                await this.markersOnly(constraintType.element, p);
             }
 
             const defaultType = bounds.elements[1];
             if (!(defaultType.element.kind === J.Kind.Empty)) {
                 p.append("=");
                 await this.visitRightPadded(defaultType, p);
+            } else {
+                await this.markersOnly(defaultType.element, p);
             }
         }
 
@@ -859,26 +847,21 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
             await this.visitModifier(m, p);
         }
 
-        const typeParameters = arrowFunction.typeParameters;
-        if (typeParameters) {
-            await this.visitNodes(typeParameters.annotations, p);
-            await this.visitSpace(typeParameters.prefix, p);
-            await this.visitMarkers(typeParameters.markers, p);
-            p.append("<");
-            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-            p.append(">");
-        }
+        await this.printTypeParameters(arrowFunction.typeParameters, p);
 
         const lambda = arrowFunction.lambda;
+        this.beforeSyntaxMarkers(lambda.markers, p);
 
         if (lambda.parameters.parenthesized) {
-            await this.visitSpace(lambda.parameters.prefix, p);
+            await this.beforeSyntax(lambda.parameters, p);
             p.append("(");
             await this.visitRightPaddedLocal(lambda.parameters.parameters, ",", p);
             p.append(")");
         } else {
+            this.beforeSyntaxMarkers(lambda.parameters.markers, p);
             await this.visitRightPaddedLocal(lambda.parameters.parameters, ",", p);
         }
+        await this.afterSyntax(lambda.parameters, p);
 
         if (arrowFunction.returnTypeExpression) {
             await this.visit(arrowFunction.returnTypeExpression, p);
@@ -887,6 +870,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         await this.visitSpace(lambda.arrow, p);
         p.append("=>");
         await this.visit(lambda.body, p);
+        await this.afterSyntax(lambda, p);
 
         await this.afterSyntax(arrowFunction, p);
         return arrowFunction;
@@ -934,15 +918,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
         await this.visitLeftPaddedLocal("type", typeDeclaration.name, p);
 
-        const typeParameters = typeDeclaration.typeParameters;
-        if (typeParameters) {
-            await this.visitNodes(typeParameters.annotations, p);
-            await this.visitSpace(typeParameters.prefix, p);
-            await this.visitMarkers(typeParameters.markers, p);
-            p.append("<");
-            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
-            p.append(">");
-        }
+        await this.printTypeParameters(typeDeclaration.typeParameters, p);
 
         await this.visitLeftPaddedLocal("=", typeDeclaration.initializer, p);
 
@@ -985,11 +961,11 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     }
 
     override async visitExportDeclaration(ed: JS.ExportDeclaration, p: PrintOutputCapture): Promise<J | undefined> {
-        await this.beforeSyntax(ed, p);
-        p.append("export");
         for (const it of ed.modifiers) {
             await this.visitModifier(it, p);
         }
+        await this.beforeSyntax(ed, p);
+        p.append("export");
 
         if (ed.typeOnly.element) {
             await this.visitLeftPaddedLocal("type", ed.typeOnly, p);
@@ -1520,16 +1496,22 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     override async visitEnumValue(enum_: J.EnumValue, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(enum_, p);
+        const computed = findMarker<Computed>(enum_.name, JS.Markers.Computed);
+        computed && p.append("[");
         await this.visit(enum_.name, p);
+        if (computed) {
+            await this.visitSpace(computed.suffix, p);
+            p.append("]");
+        }
 
         const initializer = enum_.initializer;
         if (initializer) {
-            await this.visitSpace(initializer.prefix, p);
+            await this.beforeSyntax(initializer, p);
             p.append("=");
             // There can be only one argument
             const expression = initializer.arguments.elements[0];
             await this.visitRightPadded(expression, p);
-            return enum_;
+            await this.afterSyntax(initializer, p);
         }
 
         await this.afterSyntax(enum_, p);
@@ -1717,13 +1699,14 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         await this.beforeSyntax(forLoop, p);
         p.append("for");
         const ctrl = forLoop.control;
-        await this.visitSpace(ctrl.prefix, p);
+        await this.beforeSyntax(ctrl, p);
         p.append('(');
         await this.visitRightPaddedLocal(ctrl.init, ",", p);
         p.append(';');
         ctrl.condition && await this.visitRightPaddedLocalSingle(ctrl.condition, ";", p);
         await this.visitRightPaddedLocal(ctrl.update, ",", p);
         p.append(')');
+        await this.afterSyntax(ctrl, p);
         await this.visitStatementLocal(forLoop.body, p);
         await this.afterSyntax(forLoop, p);
         return forLoop;
@@ -1737,14 +1720,17 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
             p.append("await");
         }
 
+        this.beforeSyntaxMarkers(loop.loop.markers, p);
         const control = loop.loop.control;
-        await this.visitSpace(control.prefix, p);
+        await this.beforeSyntax(control, p);
         p.append('(');
         await this.visitRightPadded(control.variable, p);
         p.append("of");
         await this.visitRightPadded(control.iterable, p);
         p.append(')');
+        await this.afterSyntax(control, p);
         await this.visitRightPadded(loop.loop.body, p);
+        await this.afterSyntax(loop.loop, p);
         await this.afterSyntax(loop, p);
         return loop;
     }
@@ -1754,12 +1740,13 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         p.append("for");
 
         const control = loop.control;
-        await this.visitSpace(control.prefix, p);
+        await this.beforeSyntax(control, p);
         p.append('(');
         await this.visitRightPadded(control.variable, p);
         p.append("in");
         await this.visitRightPadded(control.iterable, p);
         p.append(')');
+        await this.afterSyntax(control, p);
         await this.visitRightPadded(loop.body, p);
         await this.afterSyntax(loop, p);
         return loop;
@@ -1769,8 +1756,8 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     private async visitStatements(statements: J.RightPadded<Statement>[], p: PrintOutputCapture) {
         const objectLiteral =
-            this.getParentCursor(0)?.value.kind === J.Kind.Block &&
-            this.getParentCursor(1)?.value.kind === J.Kind.NewClass;
+            this.cursor.value.kind === J.Kind.Block &&
+            this.parentTree()?.kind === J.Kind.NewClass;
 
         for (let i = 0; i < statements.length; i++) {
             const paddedStat = statements[i];
@@ -1789,13 +1776,73 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         }
     }
 
-    private getParentCursor(levels: number): Cursor | undefined {
-        let cursor: Cursor | undefined = this.cursor;
-        for (let i = 0; i < levels && cursor; i++) {
-            cursor = cursor.parent;
+    // A cursor handed in by a caller holds the padding between a tree and the tree enclosing it.
+    private parentTree(): Tree | undefined {
+        return this.cursor.parentTree()?.value;
+    }
+
+    override async visitArrayAccess(arrayAccess: J.ArrayAccess, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(arrayAccess, p);
+        await this.visit(arrayAccess.indexed, p);
+        await this.visit(arrayAccess.dimension, p);
+        await this.afterSyntax(arrayAccess, p);
+        return arrayAccess;
+    }
+
+    override async visitTypeCast(typeCast: J.TypeCast, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(typeCast, p);
+        await this.visit(typeCast.class, p);
+        await this.visit(typeCast.expression, p);
+        await this.afterSyntax(typeCast, p);
+        return typeCast;
+    }
+
+    override async visitParenthesizedTypeTree(parTypeTree: J.ParenthesizedTypeTree, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(parTypeTree, p);
+        await this.visitNodes(parTypeTree.annotations, p);
+        await this.visit(parTypeTree.parenthesizedType, p);
+        await this.afterSyntax(parTypeTree, p);
+        return parTypeTree;
+    }
+
+    override async visitEmpty(empty: J.Empty, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(empty, p);
+        await this.afterSyntax(empty, p);
+        return empty;
+    }
+
+    override async visitUnknown(unknown: J.Unknown, p: PrintOutputCapture): Promise<J | undefined> {
+        await this.beforeSyntax(unknown, p);
+        await this.visit(unknown.source, p);
+        await this.afterSyntax(unknown, p);
+        return unknown;
+    }
+
+    private async printTypeParameters(typeParameters: J.TypeParameters | undefined, p: PrintOutputCapture) {
+        if (typeParameters) {
+            await this.visitNodes(typeParameters.annotations, p);
+            await this.beforeSyntaxExt(typeParameters.prefix, typeParameters.markers, p);
+            p.append("<");
+            await this.visitRightPaddedLocal(typeParameters.typeParameters, ",", p);
+            p.append(">");
+            await this.afterSyntaxMarkers(typeParameters.markers, p);
         }
+    }
 
-        return cursor;
+    // A tree that stands for something left out of the source is still printed where a recipe marked it.
+    private async markersOnly(j: J, p: PrintOutputCapture) {
+        this.beforeSyntaxMarkers(j.markers, p);
+        await this.afterSyntax(j, p);
+    }
+
+    // For a tree printed as part of another, whose prefix is not printed.
+    private beforeSyntaxMarkers(markers: Markers, p: PrintOutputCapture) {
+        for (const marker of markers.markers) {
+            p.append(p.markerPrinter.beforePrefix(marker, new Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
+        for (const marker of markers.markers) {
+            p.append(p.markerPrinter.beforeSyntax(marker, new Cursor(marker, this.cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+        }
     }
 
     protected async afterSyntax(j: J, p: PrintOutputCapture) {
@@ -1940,10 +1987,10 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
             }
             if (marker.kind === JS.Markers.Optional) {
                 await this.visitSpace((marker as Optional).prefix, p);
-                if (this.cursor.parent?.value?.kind !== J.Kind.MethodInvocation &&
-                    this.cursor.parent?.value?.kind !== JS.Kind.FunctionCall) {
+                const parent = this.parentTree()?.kind;
+                if (parent !== J.Kind.MethodInvocation && parent !== JS.Kind.FunctionCall) {
                     p.append("?");
-                    if (this.cursor.parent?.value?.kind === J.Kind.ArrayAccess) {
+                    if (parent === J.Kind.ArrayAccess) {
                         p.append(".");
                     }
                 }
@@ -1954,7 +2001,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
 
     private printComment(comment: Comment, cursor: Cursor, p: PrintOutputCapture): void {
         for (const marker of comment.markers.markers) {
-            p.append(p.markerPrinter.beforeSyntax(marker, new Cursor(this, cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+            p.append(p.markerPrinter.beforeSyntax(marker, new Cursor(comment, cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
         }
 
         if (comment.kind === J.Kind.TextComment) {
@@ -1963,7 +2010,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
         }
 
         for (const marker of comment.markers.markers) {
-            p.append(p.markerPrinter.afterSyntax(marker, new Cursor(this, cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
+            p.append(p.markerPrinter.afterSyntax(marker, new Cursor(comment, cursor), this.JAVA_SCRIPT_MARKER_WRAPPER));
         }
     }
 
@@ -1978,7 +2025,7 @@ export class JavaScriptPrinter extends JavaScriptVisitor<PrintOutputCapture> {
     override async visitControlParentheses<T extends J>(controlParens: J.ControlParentheses<T>, p: PrintOutputCapture): Promise<J | undefined> {
         await this.beforeSyntax(controlParens, p);
 
-        if (this.getParentCursor(1)?.value.kind === J.Kind.TypeCast) {
+        if (this.parentTree()?.kind === J.Kind.TypeCast) {
             p.append('<');
             await this.visitRightPaddedLocalSingle(controlParens.tree, ">", p);
         } else {

package/src/javascript/templating/engine.ts

@@ -845,9 +845,14 @@ export class TemplateApplier {
             return {...result, id: resultToUse.id};
         }
 
-        // Apply auto-formatting to the result
+        // A recipe can apply a template to a child while its cursor still points at the
+        // owning node (for example, a JSX attribute's literal value). Keep that owner
+        // in the formatting path; dropping it loses the attribute's line indentation.
+        const owner = this.cursor?.value;
+        const parent = isTree(owner) && owner.id !== originalTree.id &&
+            (await treeIds(owner as J)).has(originalTree.id) ? this.cursor : this.cursor?.parent;
         const formatted =
-            await maybeAutoFormat(originalTree, result, null, undefined, this.cursor?.parent);
+            await maybeAutoFormat(originalTree, result, null, undefined, parent);
 
         // Restore the original ID
         return {...formatted, id: resultToUse.id};

package/src/javascript/type-mapping.ts

@@ -910,6 +910,22 @@ export class JavaScriptTypeMapping {
         return method;
     }
 
+    // A method is declared by one class, which an object literal that spreads a union, for one, is not.
+    private declaringType(type: ts.Type): Type.FullyQualified {
+        const mapped = this.getType(type);
+        switch (mapped.kind) {
+            case Type.Kind.Class:
+            case Type.Kind.Annotation:
+            case Type.Kind.ShallowClass:
+            case Type.Kind.Parameterized:
+                return mapped as Type.FullyQualified;
+            case Type.Kind.Primitive:
+                return this.wrapperType(mapped as Type.Primitive);
+            default:
+                return Type.unknownType as Type.FullyQualified;
+        }
+    }
+
     private wrapperType(declaringType: (Type.FullyQualified & Type.Primitive) | Type.FullyQualified) {
         if (declaringType === Type.Primitive.String && this.stringWrapperType) {
             return this.getType(this.stringWrapperType) as Type.FullyQualified;
@@ -1184,7 +1200,7 @@ export class JavaScriptTypeMapping {
                         const parent = (symbol as any).parent;
                         if (parent) {
                             const parentType = this.checker.getDeclaredTypeOfSymbol(parent);
-                            declaringType = this.getType(parentType) as Type.FullyQualified;
+                            declaringType = this.declaringType(parentType);
                         } else {
                             declaringType = Type.unknownType as Type.FullyQualified;
                         }
@@ -1220,7 +1236,7 @@ export class JavaScriptTypeMapping {
             const parent = node.parent;
             if (ts.isClassDeclaration(parent) || ts.isInterfaceDeclaration(parent) || ts.isObjectLiteralExpression(parent)) {
                 const parentType = this.checker.getTypeAtLocation(parent);
-                declaringType = this.getType(parentType) as Type.FullyQualified;
+                declaringType = this.declaringType(parentType);
             } else {
                 declaringType = Type.unknownType as Type.FullyQualified;
             }
@@ -1243,7 +1259,7 @@ export class JavaScriptTypeMapping {
             const parent = node.parent;
             if (ts.isClassDeclaration(parent) || ts.isClassExpression(parent)) {
                 const parentType = this.checker.getTypeAtLocation(parent);
-                declaringType = this.getType(parentType) as Type.FullyQualified;
+                declaringType = this.declaringType(parentType);
             } else {
                 declaringType = Type.unknownType as Type.FullyQualified;
             }

package/src/print.ts

@@ -35,11 +35,7 @@ export namespace MarkerPrinter {
                 let searchResult = marker as SearchResult;
                 return commentWrapper(searchResult.description == null ? "" : "(" + searchResult.description + ")");
             } else if (marker.kind.startsWith("org.openrewrite.marker.Markup$")) {
-                const markup = marker as Markup;
-                const content = markup.detail
-                    ? `(${markup.message}: ${markup.detail})`
-                    : `(${markup.message})`;
-                return commentWrapper(content);
+                return commentWrapper(`(${(marker as Markup).message})`);
             }
             return "";
         },
@@ -51,6 +47,24 @@ export namespace MarkerPrinter {
         },
     }
 
+    /**
+     * As {@link DEFAULT}, but a {@link Markup} that has a detail prints it rather than its message.
+     */
+    export const VERBOSE: MarkerPrinter = {
+        beforeSyntax(marker: Marker, cursor: Cursor, commentWrapper: CommentWrapper): string {
+            if (marker.kind.startsWith("org.openrewrite.marker.Markup$")) {
+                return commentWrapper(`(${(marker as Markup).detail ?? (marker as Markup).message})`);
+            }
+            return DEFAULT.beforeSyntax(marker, cursor, commentWrapper);
+        },
+        beforePrefix(): string {
+            return "";
+        },
+        afterSyntax(): string {
+            return "";
+        },
+    }
+
     export const SEARCH_MARKERS_ONLY: MarkerPrinter = {
         beforeSyntax(marker: Marker, _cursor: Cursor, commentWrapper: CommentWrapper): string {
             if (marker.kind == MarkersKind.SearchResult) {
@@ -124,8 +138,9 @@ interface TreePrinter {
      * @param tree Helps to determine what kind of language we are dealing with when
      * printing a subtree whose LST type is shared between multiple languages in a language family.
      * @param out Accumulates printing output.
+     * @param cursor What encloses `tree`, when it is not a source file.
      */
-    print(tree: Tree, out?: PrintOutputCapture): Promise<string>;
+    print(tree: Tree, out?: PrintOutputCapture, cursor?: Cursor): Promise<string>;
 }
 
 export class TreePrinters {
@@ -134,9 +149,9 @@ export class TreePrinters {
 
     static register(kind: string, printer: () => TreeVisitor<any, PrintOutputCapture>): void {
         this._registry.set(kind, {
-            async print(tree: Tree, out?: PrintOutputCapture): Promise<string> {
+            async print(tree: Tree, out?: PrintOutputCapture, cursor?: Cursor): Promise<string> {
                 const p = out || new PrintOutputCapture();
-                await printer().visit(tree, p);
+                await printer().visit(tree, p, cursor);
                 return p.out;
             }
         })

package/src/rpc/java-rpc-client.ts

@@ -38,6 +38,8 @@ export interface JavaRpcOptions {
      * only. Does NOT configure the Java side — for that, use {@link marketplaceCsv}.
      */
     marketplace?: RecipeMarketplace;
+    /** How many messages the TS-side {@link RewriteRpc} sends per page of an object. */
+    batchSize?: number;
 }
 
 /**
@@ -116,6 +118,7 @@ export class JavaRpcTestServer {
         const rewriteRpc = new RewriteRpc(connection, {
             marketplace: opts.marketplace,
             logger: opts.logger,
+            batchSize: opts.batchSize,
         });
 
         // Hand back control once we know either (a) the JVM is up and the connection is

package/src/rpc/queue.ts

@@ -182,6 +182,13 @@ export class RpcSendQueue {
 
     send<T>(after: T | undefined, before: T | undefined, onChange?: (() => Promise<any>)): Promise<void> {
         return saveTrace(this.trace, async () => {
+            // The peer has a single absent value, and an ADD that carries nothing is not one it can decode.
+            if (after === null) {
+                after = undefined;
+            }
+            if (before === null) {
+                before = undefined;
+            }
             if (before === after) {
                 this.put({state: RpcObjectState.NO_CHANGE});
             } else if (before === undefined || (after !== undefined && this.typesAreDifferent(after, before))) {
@@ -372,10 +379,20 @@ export class StringInternTable {
     }
 }
 
+// Java's serializer names the class and numbers the object inside the value; the kind already says the first.
+function withoutSerializerKeys(value: any): any {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    const {"@c": _class, "@ref": _ref, ...fields} = value;
+    return fields;
+}
+
 export class RpcReceiveQueue {
     private batch: RpcObjectData[] = [];
     private batchIndex = 0;
     private sinceYield = 0;
+    private recorded: number[] = [];
 
     constructor(private readonly refs: Map<number, any>,
                 private readonly sourceFileType: string | undefined,
@@ -385,6 +402,23 @@ export class RpcReceiveQueue {
                 private readonly internedStrings: StringInternTable = new StringInternTable()) {
     }
 
+    private record(ref: number, value: any): void {
+        this.refs.set(ref, value);
+        this.recorded.push(ref);
+    }
+
+    /**
+     * Drops the refs this transfer defined, for when it could not be read to its end and the
+     * sender is about to forget them too.
+     * @internal
+     */
+    forgetRefs(): void {
+        for (const ref of this.recorded) {
+            this.refs.delete(ref);
+        }
+        this.recorded = [];
+    }
+
     /**
      * Returns a value rather than a promise for all but the message that refills the
      * batch or yields, so the common path costs neither a promise nor an async frame.
@@ -479,7 +513,7 @@ export class RpcReceiveQueue {
                         // For an object like JavaType that we will mutate in place rather than using
                         // immutable updates because of its cyclic nature, the before instance will ultimately
                         // be the same as the after instance below.
-                        this.refs.set(ref, before);
+                        this.record(ref, before);
                     }
                 }
             // Intentional fall-through...
@@ -492,7 +526,7 @@ export class RpcReceiveQueue {
                     after = await codec.rpcReceive(before, this);
                 } else if (message.value !== undefined) {
                     after = message.valueType ?
-                        {kind: this.internedStrings.internType(message.valueType), ...message.value} :
+                        {kind: this.internedStrings.internType(message.valueType), ...withoutSerializerKeys(message.value)} :
                         typeof message.value === "string" ? this.internedStrings.internValue(message.value) : message.value;
                 } else if (message.state === RpcObjectState.ADD && message.valueType) {
                     throw new Error(
@@ -504,7 +538,7 @@ export class RpcReceiveQueue {
                     after = before;
                 }
                 if (ref !== undefined) {
-                    this.refs.set(ref, after);
+                    this.record(ref, after);
                 }
                 return after;
             default: