@openrewrite/rewrite 8.69.0-20251209-122812 → 8.69.0-20251209-152132

package/src/javascript/tabs-and-indents-visitor.ts

@@ -34,17 +34,22 @@ import {TabsAndIndentsStyle} from "./style";
 import {findMarker} from "../markers";
 
 type IndentKind = 'block' | 'continuation' | 'align';
+type IndentContext = [number, IndentKind];  // [indent, kind]
 export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
-    private readonly singleIndent: string;
+    private readonly indentSize: number;
+    private readonly useTabCharacter: boolean;
 
     constructor(private readonly tabsAndIndentsStyle: TabsAndIndentsStyle, private stopAfter?: Tree) {
         super();
+        this.indentSize = this.tabsAndIndentsStyle.indentSize;
+        this.useTabCharacter = this.tabsAndIndentsStyle.useTabCharacter;
+    }
 
-        if (this.tabsAndIndentsStyle.useTabCharacter) {
-            this.singleIndent = "\t";
-        } else {
-            this.singleIndent = " ".repeat(this.tabsAndIndentsStyle.indentSize);
+    private indentString(indent: number): string {
+        if (this.useTabCharacter) {
+            return "\t".repeat(Math.floor(indent / this.indentSize));
         }
+        return " ".repeat(indent);
     }
 
     protected async preVisit(tree: J, _p: P): Promise<J | undefined> {
@@ -53,56 +58,90 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     private setupCursorMessagesForTree(cursor: Cursor, tree: J): void {
+        // Check if this MethodInvocation starts a method chain (select.after has newline)
+        if (tree.kind === J.Kind.MethodInvocation) {
+            const mi = tree as J.MethodInvocation;
+            if (mi.select && mi.select.after.whitespace.includes("\n")) {
+                // This MethodInvocation has a chained method call after it
+                // Store the ORIGINAL parent indent context in "chainedIndentContext"
+                // This will be propagated down and used when we reach the chain's innermost element
+                const parentContext = this.getParentIndentContext(cursor);
+                cursor.messages.set("chainedIndentContext", parentContext);
+                // For children (arguments), use continuation indent
+                // But the prefix will be normalized in postVisit using chainedIndentContext
+                const [parentIndent, parentIndentKind] = parentContext;
+                cursor.messages.set("indentContext", [parentIndent + this.indentSize, parentIndentKind] as IndentContext);
+                return;
+            }
+            // Check if we're at the base of a chain (no select) and parent has chainedIndentContext
+            if (!mi.select) {
+                const chainedContext = cursor.parent?.messages.get("chainedIndentContext") as IndentContext | undefined;
+                if (chainedContext !== undefined) {
+                    // Consume the chainedIndentContext - this is the base of the chain
+                    // The base element gets the original indent (no extra continuation)
+                    // Propagate chainedIndentContext so the `name` child knows not to add indent
+                    cursor.messages.set("indentContext", chainedContext);
+                    cursor.messages.set("chainedIndentContext", chainedContext);
+                    return;
+                }
+            }
+        }
+
+        // Check if we're the `name` of a MethodInvocation at the base of a chain
+        if (tree.kind === J.Kind.Identifier) {
+            const parentValue = cursor.parent?.value;
+            if (parentValue?.kind === J.Kind.MethodInvocation) {
+                const parentMi = parentValue as J.MethodInvocation;
+                // Check if parent has chainedIndentContext (meaning it's at the base of a chain)
+                // and we are the `name` (not an argument or something else)
+                const parentChainedContext = cursor.parent?.messages.get("chainedIndentContext") as IndentContext | undefined;
+                if (parentChainedContext !== undefined && !parentMi.select) {
+                    // We're the name of a chain-base MethodInvocation - use the chained indent directly
+                    cursor.messages.set("indentContext", parentChainedContext);
+                    return;
+                }
+            }
+        }
+
         const [parentMyIndent, parentIndentKind] = this.getParentIndentContext(cursor);
         const myIndent = this.computeMyIndent(tree, parentMyIndent, parentIndentKind);
-        cursor.messages.set("myIndent", myIndent);
 
         // For Binary, behavior depends on whether it's already on a continuation line
+        let indentKind: IndentKind;
         if (tree.kind === J.Kind.Binary) {
-            const hasNewline = tree.prefix?.whitespace?.includes("\n") ||
-                tree.prefix?.comments?.some(c => c.suffix.includes("\n"));
             // If Binary has newline OR parent is in align mode, children align
-            const shouldAlign = hasNewline || parentIndentKind === 'align';
-            cursor.messages.set("indentKind", shouldAlign ? 'align' : 'continuation');
+            const hasNewline = this.prefixContainsNewline(tree);
+            indentKind = (hasNewline || parentIndentKind === 'align') ? 'align' : 'continuation';
         } else {
-            cursor.messages.set("indentKind", this.computeIndentKind(tree));
+            indentKind = this.computeIndentKind(tree);
         }
-    }
 
-    private getParentIndentContext(cursor: Cursor): [string, IndentKind] {
-        // Find the nearest myIndent and the nearest indentKind separately
-        // Container/RightPadded/LeftPadded inherit myIndent but don't have indentKind
-        let parentIndent: string | undefined;
-        let parentKind: IndentKind | undefined;
+        cursor.messages.set("indentContext", [myIndent, indentKind] as IndentContext);
+    }
 
+    private getParentIndentContext(cursor: Cursor): IndentContext {
+        // Walk up the cursor chain to find the nearest indent context
+        // We need to walk because intermediate nodes like RightPadded may not have context set
         for (let c = cursor.parent; c != null; c = c.parent) {
-            if (parentIndent === undefined) {
-                const indent = c.messages.get("myIndent") as string | undefined;
-                if (indent !== undefined) {
-                    parentIndent = indent;
-                }
+            // chainedIndentContext stores the original context - prefer it
+            const chainedContext = c.messages.get("chainedIndentContext") as IndentContext | undefined;
+            if (chainedContext !== undefined) {
+                return chainedContext;
             }
 
-            if (parentKind === undefined) {
-                const kind = c.messages.get("indentKind") as IndentKind | undefined;
-                if (kind !== undefined) {
-                    parentKind = kind;
-                }
-            }
-
-            // Found both, we can stop
-            if (parentIndent !== undefined && parentKind !== undefined) {
-                break;
+            const context = c.messages.get("indentContext") as IndentContext | undefined;
+            if (context !== undefined) {
+                return context;
             }
         }
 
-        return [parentIndent ?? "", parentKind ?? 'continuation'];
+        return [0, 'continuation'];
     }
 
-    private computeMyIndent(tree: J, parentMyIndent: string, parentIndentKind: IndentKind): string {
-        // CompilationUnit is the root - it always has myIndent="" regardless of prefix content
+    private computeMyIndent(tree: J, parentMyIndent: number, parentIndentKind: IndentKind): number {
+        // CompilationUnit is the root - it always has myIndent=0 regardless of prefix content
         if (tree.kind === JS.Kind.CompilationUnit) {
-            return "";
+            return 0;
         }
         // TemplateExpressionSpan: reset indent context - template literal content determines its own indentation
         // The expression inside ${...} should be indented based on where it appears in the template, not outer code
@@ -112,32 +151,38 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             const prefix = span.expression?.prefix?.whitespace ?? "";
             const lastNewline = prefix.lastIndexOf("\n");
             if (lastNewline >= 0) {
-                return prefix.slice(lastNewline + 1);
+                return prefix.length - lastNewline - 1;
             }
-            return "";
+            return 0;
         }
         if (tree.kind === J.Kind.IfElse || parentIndentKind === 'align') {
             return parentMyIndent;
         }
+        // Certain structures don't add indent for themselves - they stay at parent level
+        // - TryCatch: catch clause is part of try statement
+        // - TypeLiteral: { members } in type definitions
+        // - EnumValueSet: enum members get same indent as the set itself
+        if (tree.kind === J.Kind.TryCatch || tree.kind === JS.Kind.TypeLiteral || tree.kind === J.Kind.EnumValueSet) {
+            return parentMyIndent;
+        }
         // Only add indent if this element starts on a new line
         // Check both the element's prefix and any Spread marker's prefix
         const hasNewline = this.prefixContainsNewline(tree);
         if (!hasNewline) {
             // Special case for JSX: children of JsxTag don't have newlines in their prefix
-            // (newlines are in text Literal nodes), but nested tags should still get block indent
-            if (this.isNestedJsxTag(tree)) {
-                return parentMyIndent + this.singleIndent;
+            // (newlines are in text Literal nodes), but JSX children should still get block indent
+            if (this.isJsxChildElement(tree)) {
+                return parentMyIndent + this.indentSize;
             }
             return parentMyIndent;
         }
         // Add indent for block children or continuation
-        return parentMyIndent + this.singleIndent;
+        return parentMyIndent + this.indentSize;
     }
 
     private prefixContainsNewline(tree: J): boolean {
-        // Check the element's own prefix
-        if (tree.prefix?.whitespace?.includes("\n") ||
-            tree.prefix?.comments?.some(c => c.suffix.includes("\n"))) {
+        // Check if the element starts on a new line (only the last whitespace matters)
+        if (tree.prefix && lastWhitespace(tree.prefix).includes("\n")) {
             return true;
         }
         // For elements with Spread marker, check the Spread marker's prefix
@@ -148,9 +193,11 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         return false;
     }
 
-    private isNestedJsxTag(tree: J): boolean {
-        // Check if this is a JsxTag whose parent is also a JsxTag
-        if (tree.kind !== JS.Kind.JsxTag) {
+    private isJsxChildElement(tree: J): boolean {
+        // Check if this is a JSX child element whose parent is a JsxTag
+        // JSX children (JsxTag, JsxEmbeddedExpression) don't have newlines in their own prefix
+        // (newlines are in text Literal nodes), but they should still get block indent
+        if (tree.kind !== JS.Kind.JsxTag && tree.kind !== JS.Kind.JsxEmbeddedExpression) {
             return false;
         }
         const parentTree = this.cursor.parentTree();
@@ -162,6 +209,8 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             case J.Kind.Block:
             case J.Kind.Case:
             case JS.Kind.JsxTag:
+            case JS.Kind.TypeLiteral:
+            case J.Kind.EnumValueSet:
                 return 'block';
             case JS.Kind.CompilationUnit:
                 return 'align';
@@ -175,17 +224,40 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             this.cursor?.root.messages.set("stop", true);
         }
 
-        const myIndent = this.cursor.messages.get("myIndent") as string | undefined;
-        if (myIndent === undefined) {
+        // If parent has chainedIndentContext but no indentContext yet, we're exiting a chain element
+        // Set indentContext on parent = [chainedIndent + indentSize, chainedIndentKind]
+        // This only happens once at the innermost element; subsequent parents will already have indentContext
+        const parentChainedContext = this.cursor.parent?.messages.get("chainedIndentContext") as IndentContext | undefined;
+        const parentHasIndentContext = this.cursor.parent?.messages.has("indentContext");
+        if (parentChainedContext !== undefined && !parentHasIndentContext) {
+            const [chainedIndent, chainedIndentKind] = parentChainedContext;
+            this.cursor.parent!.messages.set("indentContext", [chainedIndent + this.indentSize, chainedIndentKind] as IndentContext);
+        }
+
+        const indentContext = this.cursor.messages.get("indentContext") as IndentContext | undefined;
+        if (indentContext === undefined) {
             return tree;
         }
+        let [myIndent] = indentContext;
+
+        // For chain-start MethodInvocations, the prefix contains whitespace before the chain BASE
+        // Use chainedIndentContext (the original indent) for the prefix, not the continuation indent
+        const chainedContext = this.cursor.messages.get("chainedIndentContext") as IndentContext | undefined;
+        if (chainedContext !== undefined && tree.kind === J.Kind.MethodInvocation) {
+            const mi = tree as J.MethodInvocation;
+            if (mi.select && mi.select.after.whitespace.includes("\n")) {
+                // This is a chain-start - use original indent for prefix normalization
+                myIndent = chainedContext[0];
+            }
+        }
 
         let result = tree;
+        const indentStr = this.indentString(myIndent);
 
         // Check if the element has a Spread marker - if so, normalize its prefix instead
         const spreadMarker = result.markers?.markers?.find(m => m.kind === JS.Markers.Spread) as { prefix: J.Space } | undefined;
         if (spreadMarker && spaceContainsNewline(spreadMarker.prefix)) {
-            const normalizedPrefix = normalizeSpaceIndent(spreadMarker.prefix, myIndent);
+            const normalizedPrefix = normalizeSpaceIndent(spreadMarker.prefix, indentStr);
             if (normalizedPrefix !== spreadMarker.prefix) {
                 result = produce(result, draft => {
                     const spreadIdx = draft.markers.markers.findIndex(m => m.kind === JS.Markers.Spread);
@@ -196,7 +268,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             }
         } else if (result.prefix && spaceContainsNewline(result.prefix)) {
             // Normalize the entire prefix space including comment suffixes
-            const normalizedPrefix = normalizeSpaceIndent(result.prefix, myIndent);
+            const normalizedPrefix = normalizeSpaceIndent(result.prefix, indentStr);
             if (normalizedPrefix !== result.prefix) {
                 result = produce(result, draft => {
                     draft.prefix = normalizedPrefix;
@@ -218,21 +290,22 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         return parentTree !== undefined && parentTree.value.kind === JS.Kind.JsxTag;
     }
 
-    private normalizeJsxTextContent(literal: J.Literal, myIndent: string): J.Literal {
+    private normalizeJsxTextContent(literal: J.Literal, myIndent: number): J.Literal {
         if (!literal.valueSource || !literal.valueSource.includes("\n")) {
             return literal;
         }
 
         // Check if this literal is the last child of a JsxTag - if so, its trailing whitespace
         // should use the parent tag's indent, not the content indent
-        const parentIndent = this.cursor.parentTree()!.messages.get("myIndent") as string | undefined;
+        const parentContext = this.cursor.parentTree()!.messages.get("indentContext") as IndentContext | undefined;
+        const parentIndent = parentContext?.[0];
         const isLastChild = parentIndent !== undefined && this.isLastChildOfJsxTag(literal);
 
         // For JSX text content, the newline is in the value, not the prefix.
         // Since the content IS effectively on a new line, it should get block child indent.
         // myIndent is the parent's indent (because Literal prefix has no newline),
-        // so we need to add singleIndent for content lines.
-        const contentIndent = myIndent + this.singleIndent;
+        // so we need to add indentSize for content lines.
+        const contentIndent = myIndent + this.indentSize;
 
         // Split by newlines and normalize each line's indentation
         const lines = literal.valueSource.split('\n');
@@ -251,17 +324,17 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
                 // Line has only whitespace (or is empty)
                 if (isLastChild && i === lines.length - 1) {
                     // Trailing whitespace of last child - use parent indent for closing tag alignment
-                    result.push(parentIndent!);
+                    result.push(this.indentString(parentIndent!));
                 } else if (i < lines.length - 1) {
                     // Empty line in the middle (followed by more lines) - keep empty
                     result.push('');
                 } else {
                     // Trailing whitespace of non-last-child - add content indent
-                    result.push(contentIndent);
+                    result.push(this.indentString(contentIndent));
                 }
             } else {
                 // Line has content - add proper indent
-                result.push(contentIndent + content);
+                result.push(this.indentString(contentIndent) + content);
             }
         }
 
@@ -287,13 +360,13 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         return false;
     }
 
-    private normalizeBlockEnd(block: J.Block, myIndent: string): J.Block {
+    private normalizeBlockEnd(block: J.Block, myIndent: number): J.Block {
         const effectiveLastWs = lastWhitespace(block.end);
         if (!effectiveLastWs.includes("\n")) {
             return block;
         }
         return produce(block, draft => {
-            draft.end = replaceLastWhitespace(draft.end, ws => replaceIndentAfterLastNewline(ws, myIndent));
+            draft.end = replaceLastWhitespace(draft.end, ws => replaceIndentAfterLastNewline(ws, this.indentString(myIndent)));
         });
     }
 
@@ -302,7 +375,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         this.cursor = new Cursor(container, this.cursor);
 
         // Pre-visit hook: set up cursor messages
-        this.preVisitContainer(container);
+        this.preVisitContainer();
 
         // Visit children (similar to base visitor but without cursor management)
         let ret = (await produceAsync<J.Container<T>>(container, async draft => {
@@ -320,58 +393,15 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         return ret;
     }
 
-    private preVisitContainer<T extends J>(container: J.Container<T>): void {
-        let myIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
-
-        // Check if we're in a method chain - use chainedIndent if available
-        // This ensures arguments inside method chains like `.select(arg)` inherit the chain's indent level
-        // BUT stop at scope boundaries:
-        // 1. Blocks - nested code inside callbacks should NOT use outer chainedIndent
-        // 2. Other Containers - nested function call arguments should NOT use outer chainedIndent
-        for (let c = this.cursor.parent; c; c = c.parent) {
-            // Stop searching if we hit a Block (function body, arrow function body, etc.)
-            // This prevents chainedIndent from leaking into nested scopes
-            if (c.value?.kind === J.Kind.Block) {
-                break;
-            }
-            // Stop searching if we hit another Container (arguments of another function call)
-            // This prevents chainedIndent from leaking into nested function calls
-            if (c.value?.kind === J.Kind.Container) {
-                break;
-            }
-            const chainedIndent = c.messages.get("chainedIndent") as string | undefined;
-            if (chainedIndent !== undefined) {
-                myIndent = chainedIndent;
-                break;
-            }
-        }
-
-        this.cursor.messages.set("myIndent", myIndent);
-        this.cursor.messages.set("indentKind", 'continuation');
+    private preVisitContainer(): void {
+        const parentContext = this.cursor.parent?.messages.get("indentContext") as IndentContext | undefined;
+        const [myIndent] = parentContext ?? [0, 'continuation'];
+        this.cursor.messages.set("indentContext", [myIndent, 'continuation'] as IndentContext);
     }
 
     private postVisitContainer<T extends J>(container: J.Container<T>): J.Container<T> {
-        let parentIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
-
-        // Check for chainedIndent for closing delimiter alignment in method chains
-        // BUT stop at scope boundaries:
-        // 1. Blocks - nested code inside callbacks should NOT use outer chainedIndent
-        // 2. Other Containers - nested function call arguments should NOT use outer chainedIndent
-        for (let c = this.cursor.parent; c; c = c.parent) {
-            // Stop searching if we hit a Block (function body, arrow function body, etc.)
-            if (c.value?.kind === J.Kind.Block) {
-                break;
-            }
-            // Stop searching if we hit another Container (arguments of another function call)
-            if (c.value?.kind === J.Kind.Container) {
-                break;
-            }
-            const chainedIndent = c.messages.get("chainedIndent") as string | undefined;
-            if (chainedIndent !== undefined) {
-                parentIndent = chainedIndent;
-                break;
-            }
-        }
+        const parentContext = this.cursor.parent?.messages.get("indentContext") as IndentContext | undefined;
+        const [parentIndent] = parentContext ?? [0, 'continuation'];
 
         // Normalize the last element's after whitespace (closing delimiter like `)`)
         // The closing delimiter should align with the parent's indent level
@@ -380,7 +410,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             if (effectiveLastWs.includes("\n")) {
                 return produce(container, draft => {
                     const lastDraft = draft.elements[draft.elements.length - 1];
-                    lastDraft.after = replaceLastWhitespace(lastDraft.after, ws => replaceIndentAfterLastNewline(ws, parentIndent));
+                    lastDraft.after = replaceLastWhitespace(lastDraft.after, ws => replaceIndentAfterLastNewline(ws, this.indentString(parentIndent)));
                 });
             }
         }
@@ -419,24 +449,21 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     private preVisitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>): void {
-        // Get parent indent from parent cursor
-        const parentIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
+        const parentContext = this.cursor.parent?.messages.get("indentContext") as IndentContext | undefined;
+        const [parentIndent, parentIndentKind] = parentContext ?? [0, 'continuation'];
         const hasNewline = left.before.whitespace.includes("\n");
 
         // Check if parent is a Binary in align mode - if so, don't add continuation indent
-        // (Binary sets indentKind='align' when it's already on a continuation line)
         const parentValue = this.cursor.parent?.value;
-        const parentIndentKind = this.cursor.parent?.messages.get("indentKind");
         const shouldAlign = parentValue?.kind === J.Kind.Binary && parentIndentKind === 'align';
 
         // Compute myIndent INCLUDING continuation if applicable
-        // This ensures child elements see the correct parent indent
         let myIndent = parentIndent;
         if (hasNewline && !shouldAlign) {
-            myIndent = parentIndent + this.singleIndent;
+            myIndent = parentIndent + this.indentSize;
         }
 
-        this.cursor.messages.set("myIndent", myIndent);
+        this.cursor.messages.set("indentContext", [myIndent, 'continuation'] as IndentContext);
         this.cursor.messages.set("hasNewline", hasNewline);
     }
 
@@ -452,10 +479,11 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             return left;
         }
 
-        // Use the myIndent we computed in preVisitLeftPadded (which includes continuation if applicable)
-        const targetIndent = this.cursor.messages.get("myIndent") as string ?? "";
+        // Use the indent we computed in preVisitLeftPadded (which includes continuation if applicable)
+        const context = this.cursor.messages.get("indentContext") as IndentContext | undefined;
+        const [targetIndent] = context ?? [0, 'continuation'];
         return produce(left, draft => {
-            draft.before.whitespace = replaceIndentAfterLastNewline(draft.before.whitespace, targetIndent);
+            draft.before.whitespace = replaceIndentAfterLastNewline(draft.before.whitespace, this.indentString(targetIndent));
         });
     }
 
@@ -488,74 +516,44 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     private preVisitRightPadded<T extends J | boolean>(right: J.RightPadded<T>): void {
-        // Get parent indent from parent cursor
-        const parentIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
-        const parentIndentKind = this.cursor.parent?.messages.get("indentKind") as string ?? "";
+        const parentContext = this.cursor.parent?.messages.get("indentContext") as IndentContext | undefined;
+        const [parentIndent, parentIndentKind] = parentContext ?? [0, 'continuation'];
 
-        // Check if the `after` has a newline (e.g., in method chains like `db\n    .from()`)
-        const hasNewline = right.after.whitespace.includes("\n");
+        // Check if parent has chainedIndentContext - if so, this is the select of a method chain
+        // Propagate chainedIndentContext but do NOT set indentContext
+        const parentChainedContext = this.cursor.parent?.messages.get("chainedIndentContext") as IndentContext | undefined;
+        if (parentChainedContext !== undefined) {
+            this.cursor.messages.set("chainedIndentContext", parentChainedContext);
+            // Do NOT set indentContext - child elements will use chainedIndentContext
+            return;
+        }
 
-        // Only apply chainedIndent logic for method chains (when parent is a MethodInvocation)
-        const parentKind = this.cursor.parent?.value?.kind;
-        const isMethodChain = parentKind === J.Kind.MethodInvocation;
+        // Check if Parentheses wraps a Binary expression - if so, let Binary handle its own indent
+        const rightPaddedParentKind = this.cursor.parent?.value?.kind;
+        const elementKind = (right.element as any)?.kind;
+        const isParenthesesWrappingBinary = rightPaddedParentKind === J.Kind.Parentheses &&
+            elementKind === J.Kind.Binary;
 
         let myIndent = parentIndent;
-        if (hasNewline && isMethodChain) {
-            // Search up the cursor hierarchy for an existing chainedIndent (to avoid stacking in method chains)
-            let existingChainedIndent: string | undefined;
-            for (let c = this.cursor.parent; c; c = c.parent) {
-                existingChainedIndent = c.messages.get("chainedIndent") as string | undefined;
-                if (existingChainedIndent !== undefined) {
-                    break;
-                }
-            }
-            if (existingChainedIndent === undefined) {
-                myIndent = parentIndent + this.singleIndent;
-                // Set chainedIndent on parent so further chain elements don't stack
-                this.cursor.parent?.messages.set("chainedIndent", myIndent);
-            } else {
-                myIndent = existingChainedIndent;
-            }
-        } else if (parentIndentKind !== 'align' && isJava(right.element) && this.elementPrefixContainsNewline(right.element as J)) {
-            myIndent = parentIndent + this.singleIndent;
+        if (!isParenthesesWrappingBinary && parentIndentKind !== 'align' && isJava(right.element) && this.prefixContainsNewline(right.element as J)) {
+            myIndent = parentIndent + this.indentSize;
             // For spread elements with newlines, mark continuation as established
-            // This allows subsequent elements on the SAME line to inherit the continuation level
             const element = right.element as J;
             if (this.isSpreadElement(element)) {
                 this.cursor.parent?.messages.set("continuationIndent", myIndent);
             }
-        } else if (isJava(right.element) && !this.elementPrefixContainsNewline(right.element as J)) {
+        } else if (isJava(right.element) && !this.prefixContainsNewline(right.element as J)) {
             // Element has no newline - check if a previous sibling established continuation
-            const continuationIndent = this.cursor.parent?.messages.get("continuationIndent") as string | undefined;
+            const continuationIndent = this.cursor.parent?.messages.get("continuationIndent") as number | undefined;
             if (continuationIndent !== undefined) {
                 myIndent = continuationIndent;
             }
         }
 
-        this.cursor.messages.set("myIndent", myIndent);
         // Set 'align' for most RightPadded elements to prevent double-continuation
-        // EXCEPT when Parentheses wraps a Binary expression - in that case, the Binary's
-        // children need continuation mode to get proper indentation for multi-line operands
-        const rightPaddedParentKind = this.cursor.parent?.value?.kind;
-        const elementKind = (right.element as any)?.kind;
-        const isParenthesesWrappingBinary = rightPaddedParentKind === J.Kind.Parentheses &&
-            elementKind === J.Kind.Binary;
-        if (!isParenthesesWrappingBinary) {
-            this.cursor.messages.set("indentKind", "align");
-        }
-    }
-
-    private elementPrefixContainsNewline(element: J): boolean {
-        // Check the element's own prefix
-        if (lastWhitespace(element.prefix).includes("\n")) {
-            return true;
-        }
-        // Also check for Spread marker's prefix
-        const spreadMarker = element.markers?.markers?.find(m => m.kind === JS.Markers.Spread) as { prefix: J.Space } | undefined;
-        if (spreadMarker && spaceContainsNewline(spreadMarker.prefix)) {
-            return true;
-        }
-        return false;
+        // EXCEPT when Parentheses wraps a Binary expression - use continuation so Binary children align
+        const indentKind: IndentKind = isParenthesesWrappingBinary ? 'continuation' : 'align';
+        this.cursor.messages.set("indentContext", [myIndent, indentKind] as IndentContext);
     }
 
     /**
@@ -594,7 +592,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     private setupAncestorIndents(): void {
         const path: Cursor[] = [];
         let anchorCursor: Cursor | undefined;
-        let anchorIndent = "";
+        let anchorIndent = 0;
 
         for (let c = this.cursor.parent; c; c = c.parent) {
             path.push(c);
@@ -605,14 +603,14 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
                 const idx = ws.lastIndexOf('\n');
                 if (idx !== -1) {
                     anchorCursor = c;
-                    anchorIndent = ws.substring(idx + 1);
+                    anchorIndent = ws.length - idx - 1;
                 }
             }
 
             if (v.kind === JS.Kind.CompilationUnit) {
                 if (!anchorCursor) {
                     anchorCursor = c;
-                    anchorIndent = "";
+                    anchorIndent = 0;
                 }
                 break;
             }
@@ -628,8 +626,7 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             const savedCursor = this.cursor;
             this.cursor = c;
             if (c === anchorCursor) {
-                c.messages.set("myIndent", anchorIndent);
-                c.messages.set("indentKind", this.computeIndentKind(v));
+                c.messages.set("indentContext", [anchorIndent, this.computeIndentKind(v)] as IndentContext);
             } else {
                 this.setupCursorMessagesForTree(c, v);
             }