@openrewrite/rewrite 8.92.16 → 8.92.18

package/src/javascript/amd.ts

@@ -24,7 +24,6 @@ import {
     J,
     rightPadded,
     space,
-    spaceContainsNewline,
     Statement,
     TrailingComma
 } from "../java";
@@ -193,16 +192,20 @@ export function parameterNames(block: AmdBlock): (string | undefined)[] {
 }
 
 export function identifierOf(parameter: J): J.Identifier | undefined {
-    if (parameter.kind === J.Kind.VariableDeclarations) {
-        const name = (parameter as J.VariableDeclarations).variables[0]?.element.name;
-        return name !== undefined && isIdentifier(name) ? name : undefined;
-    }
-    return isIdentifier(parameter) ? parameter : undefined;
+    const name = declaredNameOf(parameter);
+    return name !== undefined && isIdentifier(name) ? name : undefined;
+}
+
+/** The name a factory parameter binds, which may be a destructuring pattern. */
+function declaredNameOf(parameter: J): J | undefined {
+    return parameter.kind === J.Kind.VariableDeclarations ?
+        (parameter as J.VariableDeclarations).variables[0]?.element.name :
+        parameter;
 }
 
 /**
  * Where an entry's leading whitespace sits. A dependency string carries it directly, while
- * a factory parameter carries it on the identifier inside the declaration that wraps it.
+ * a factory parameter carries it on the name its declaration wraps, even a destructuring one.
  */
 interface Slot<T extends J> {
     prefixOf(element: T): J.Space;
@@ -216,7 +219,7 @@ const dependencySlot: Slot<Expression> = {
 };
 
 const parameterSlot: Slot<J> = {
-    prefixOf: element => identifierOf(element)?.prefix ?? element.prefix,
+    prefixOf: element => declaredNameOf(element)?.prefix ?? element.prefix,
     withPrefix: (element, prefix) => {
         if (element.kind !== J.Kind.VariableDeclarations) {
             return {...element, prefix};
@@ -257,14 +260,27 @@ function moveTrailingComma<T extends J>(
 
 /**
  * The whitespace that separates one entry from the next, taken from the entries already
- * there so that a block listing its dependencies one per line keeps doing so.
+ * there so that a block listing its dependencies one per line keeps doing so. Comments in an
+ * entry's prefix document that entry, so they stay behind.
  */
 function separator<T extends J>(entries: readonly J.RightPadded<T>[], slot: Slot<T>): J.Space {
     if (entries.length >= 2) {
-        return slot.prefixOf(entries[1].element);
+        return space(layoutOf(slot.prefixOf(entries[1].element)));
+    }
+    const first = layoutOf(slot.prefixOf(entries[0].element));
+    return space(first.includes("\n") ? first : " ");
+}
+
+/**
+ * The prefix without its comments. That is the segment holding the line break, preferring the
+ * last comment's suffix, else the whitespace before the entry.
+ */
+function layoutOf(prefix: J.Space): string {
+    const last = prefix.comments[prefix.comments.length - 1];
+    if (last === undefined || (!last.suffix.includes("\n") && prefix.whitespace.includes("\n"))) {
+        return prefix.whitespace;
     }
-    const first = slot.prefixOf(entries[0].element);
-    return spaceContainsNewline(first) ? first : space(" ");
+    return last.suffix;
 }
 
 /**

package/src/javascript/autodetect.ts

@@ -123,13 +123,13 @@ class TabsAndIndentsStatistics {
     private totalSpaceIndents = 0;
     private totalTabIndents = 0;
 
-    // Track all observed indent sizes to compute GCD
-    private observedIndents: number[] = [];
+    // How often a block was seen indenting its statements by each width past the enclosing block's
+    private readonly levelWidths = new Map<number, number>();
 
-    recordSpaceIndent(spaceCount: number): void {
+    recordSpaceIndent(width: number): void {
         this.totalSpaceIndents++;
-        if (spaceCount > 0) {
-            this.observedIndents.push(spaceCount);
+        if (width > 0) {
+            this.levelWidths.set(width, (this.levelWidths.get(width) ?? 0) + 1);
         }
     }
 
@@ -141,23 +141,14 @@ class TabsAndIndentsStatistics {
         // Determine if using tabs or spaces
         const useTabs = this.totalTabIndents > this.totalSpaceIndents;
 
-        // Find indent size by computing GCD of all observed indents
-        // This correctly handles 2-space files where we see 2, 4, 6, 8... (all multiples of 2)
+        // The width most statements agree on, so a stray misindented line is outvoted
         let detectedIndentSize = 4; // Default
-        if (this.observedIndents.length > 0) {
-            // Compute GCD of all observed indents
-            let gcd = this.observedIndents[0];
-            for (let i = 1; i < this.observedIndents.length; i++) {
-                gcd = this.computeGcd(gcd, this.observedIndents[i]);
-                if (gcd === 1) break; // Can't get smaller than 1
-            }
-            // Only use common indent sizes (2, 4, 8)
-            if (gcd === 2 || gcd === 4 || gcd === 8) {
-                detectedIndentSize = gcd;
-            } else if (gcd > 0 && gcd % 4 === 0) {
-                detectedIndentSize = 4;
-            } else if (gcd > 0 && gcd % 2 === 0) {
-                detectedIndentSize = 2;
+        let votes = 0;
+        for (const size of [2, 4, 8]) {
+            const count = this.levelWidths.get(size) ?? 0;
+            if (count > votes) {
+                detectedIndentSize = size;
+                votes = count;
             }
         }
 
@@ -172,15 +163,6 @@ class TabsAndIndentsStatistics {
             indentAllChainedCallsInAGroup: false
         };
     }
-
-    private computeGcd(a: number, b: number): number {
-        while (b !== 0) {
-            const temp = b;
-            b = a % b;
-            a = temp;
-        }
-        return a;
-    }
 }
 
 /**
@@ -272,23 +254,32 @@ class FindIndentVisitor extends JavaScriptVisitor<any> {
         super();
     }
 
+    /** The indent of the statements in each enclosing block, innermost last. */
+    private readonly enclosing: number[] = [];
+
     protected async visitBlock(block: J.Block, p: any): Promise<J | undefined> {
-        // Check indentation of statements in the block
+        const outer = this.enclosing[this.enclosing.length - 1] ?? 0;
+        let own: number | undefined;
         for (const stmt of block.statements) {
             const whitespace = stmt.element.prefix?.whitespace;
-            if (whitespace) {
-                this.analyzeIndent(whitespace);
-            }
+            const indent = whitespace ? this.analyzeIndent(whitespace, outer) : undefined;
+            own ??= indent;
+        }
+        this.enclosing.push(own ?? outer);
+        try {
+            return await super.visitBlock(block, p);
+        } finally {
+            this.enclosing.pop();
         }
-        return super.visitBlock(block, p);
     }
 
-    private analyzeIndent(whitespace: string): void {
+    /** Records the indent `whitespace` ends in, relative to `outer`, and returns it if it is spaces. */
+    private analyzeIndent(whitespace: string, outer: number): number | undefined {
         const newlineIndex = whitespace.lastIndexOf('\n');
-        if (newlineIndex < 0) return;
+        if (newlineIndex < 0) return undefined;
 
         const indent = whitespace.substring(newlineIndex + 1);
-        if (indent.length === 0) return;
+        if (indent.length === 0) return 0;
 
         // Check first character to determine type
         if (indent[0] === '\t') {
@@ -300,10 +291,10 @@ class FindIndentVisitor extends JavaScriptVisitor<any> {
                 if (char === ' ') spaceCount++;
                 else break;
             }
-            if (spaceCount > 0) {
-                this.stats.recordSpaceIndent(spaceCount);
-            }
+            this.stats.recordSpaceIndent(spaceCount - outer);
+            return spaceCount;
         }
+        return undefined;
     }
 }
 

package/src/javascript/binding.ts

@@ -16,10 +16,11 @@
 import {J} from "../java";
 import {JS} from "./tree";
 import {JavaScriptVisitor} from "./visitor";
-import {compilationUnitOf, cursorOf, declarationsOf, namesUsedIn, scopeOf} from "./scope";
+import {compilationUnitOf, cursorOf, declarationsOf, isReference, namesUsedIn, scopeOf} from "./scope";
+import {Cursor, isTree} from "../tree";
 import {
-    AddImportOptions, bindImport, existingImportBinding, ExistingImportBinding, hasEsmSyntax, isCommonJs, memberName,
-    moduleNameOf, nameTaken, RebindImport, requiredModuleOfDeclaration
+    AddImportOptions, bindImport, bindingShape, existingImportBinding, ExistingImportBinding, hasEsmSyntax, isCommonJs,
+    memberName, moduleNameOf, nameTaken, RebindImport, requiredModuleOfDeclaration
 } from "./add-import";
 import {RemoveImport} from "./remove-import";
 import {
@@ -229,7 +230,7 @@ function moduleObjectBindings(cu: JS.CompilationUnit): ModuleObjectBinding[] {
  * never a type-only import for a value, which erases and would leave the reference unbound.
  */
 function answersWholeModuleRequest(binding: ModuleObjectBinding, wantsNamespace: boolean, typeOnly: boolean): boolean {
-    return binding.typeOnly === typeOnly &&
+    return (typeOnly || !binding.typeOnly) &&
         (binding.shape === "require" || binding.shape === (wantsNamespace ? "namespace" : "default"));
 }
 
@@ -274,9 +275,10 @@ export function maybeBind(
         }
     }
 
-    if (isWholeModule && options.preferredName === undefined && derivedBindingName(module) === undefined) {
-        // The module's last path segment is not a legal identifier, and the caller named no
-        // preference of its own — there is no name left to bind it to.
+    if (isWholeModule && options.alias === undefined && options.preferredName === undefined &&
+        derivedBindingName(module) === undefined) {
+        // The module's last path segment is not a legal identifier, and the caller named none
+        // of its own — there is no name left to bind it to.
         return undefined;
     }
 
@@ -318,17 +320,13 @@ function sameCallees(a: readonly string[], b: readonly string[]): boolean {
     return a.length === b.length && a.every((callee, i) => callee === b[i]);
 }
 
-/** Which of an import clause's three slots `member` binds — `import`, `import *`, or `import {}`. */
-function bindingShape(member: string | undefined): "default" | "namespace" | "named" {
-    const key = memberName(member);
-    return key === undefined ? "default" : key === "*" ? "namespace" : "named";
-}
-
 /**
- * Moves the binding for `from` to `to` and answers with the name it now carries — the primitive
- * behind a member rename or a module move. Returns `undefined`, changing nothing, where the move
- * is not safely expressible; the refusals and the choice of name are listed in CLAUDE.md:
- * JavaScript module bindings.
+ * Moves the binding for `from` to `to` and answers with the name it now carries, or `undefined`,
+ * changing nothing, where the move cannot be expressed safely. One call moves one binding.
+ * Named members of one import moved to one module, a call each, end up in one import of it,
+ * whether the calls share a visit or come from separate recipes.
+ * On an ES import, every type in the file naming what moved is renamed the way a parse of the result names it.
+ * It is renamed, not re-resolved, so a moved member keeps its old declaration's signature.
  */
 export function maybeRebind(visitor: JavaScriptVisitor<any>, options: MaybeRebindOptions): string | undefined {
     const amd = enclosingAmdBlock(visitor, options);
@@ -361,10 +359,9 @@ export function maybeRebind(visitor: JavaScriptVisitor<any>, options: MaybeRebin
     if (existing === undefined) {
         return undefined;
     }
-    if (existing.onlyMemberOfStatement && bindingShape(options.from.member) !== bindingShape(options.to.member)) {
-        return undefined;
-    }
-    if (!existing.onlyMemberOfStatement && isCommonJs(cu)) {
+    // `RebindImport` replaces a statement it cannot rewrite in place, and a CommonJS file can gain no import.
+    if (isCommonJs(cu) &&
+        (!existing.onlyMemberOfStatement || bindingShape(options.from.member) !== bindingShape(options.to.member))) {
         return undefined;
     }
     const boundName = rebindingName(visitor, cu, options, existing);
@@ -390,7 +387,8 @@ function rebindingName(
     options: MaybeRebindOptions,
     existing: ExistingImportBinding
 ): string | undefined {
-    const taken = (name: string) => nameTaken(name, namesUsedIn(cu), visitor);
+    const taken = (name: string) => nameTaken(name, noNames, visitor) ||
+        (namesUsedIn(cu).has(name) && !reusesTargetImport(cu, name, options.to, existing));
     const alias = options.to.alias;
     if (alias !== undefined) {
         return isBindableName(alias) && (alias === existing.localName || !taken(alias)) ? alias : undefined;
@@ -402,6 +400,50 @@ function rebindingName(
     return taken(member) ? existing.localName : member;
 }
 
+const noNames: ReadonlySet<string> = new Set();
+
+/** Whether the moved binding can merge into a value import of `to`'s named member that `name` binds. */
+function reusesTargetImport(
+    cu: JS.CompilationUnit,
+    name: string,
+    to: MaybeRebindOptions["to"],
+    moved: ExistingImportBinding
+): boolean {
+    const target = existingImportBinding(cu, to.module, to.member);
+    return target?.localName === name && bindingShape(to.member) === "named" && !target.typeOnly &&
+        !moved.typeOnly && onlyReferences(cu, name);
+}
+
+/**
+ * Whether every spelling of `name` outside the imports is a reference. Any binder spells its name
+ * in a declaring position, so each reference then reads the import, whatever kind of scope it is in.
+ */
+function onlyReferences(cu: JS.CompilationUnit, name: string): boolean {
+    let references = true;
+    const visit = (node: any, parent: Cursor): void => {
+        if (!references) {
+            return;
+        }
+        if (Array.isArray(node)) {
+            node.forEach(child => visit(child, parent));
+            return;
+        }
+        const cursor = new Cursor(node, parent);
+        if (node?.kind === J.Kind.Identifier && node.simpleName === name) {
+            references = isReference(cursor, node);
+        } else if (isTree(node) || node?.kind === J.Kind.RightPadded || node?.kind === J.Kind.LeftPadded ||
+            node?.kind === J.Kind.Container) {
+            Object.entries(node).forEach(([key, value]) => key !== 'markers' && visit(value, cursor));
+        }
+    };
+    const root = new Cursor(cu);
+    // An import or an `export {…}` binds nothing the name could collide with.
+    cu.statements
+        .filter(s => s.element?.kind !== JS.Kind.Import && s.element?.kind !== JS.Kind.ExportDeclaration)
+        .forEach(s => visit(s, root));
+    return references;
+}
+
 /**
  * @deprecated Use {@link maybeUnbind} instead — this is a call-shape change, not a behaviour
  * change: `maybeRemoveImport(v, module, member)` is `maybeUnbind(v, {module, member})`.

package/src/javascript/comparator.ts

@@ -2347,15 +2347,15 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         return true;
     }
 
-    /** Whether the receiver has to be walked even where attribution alone settles the call. */
-    protected selectMustBeVisited(_method: J.MethodInvocation): boolean {
+    /** Whether a call declared on `declaringType` matches a call of the same name declared on any type. */
+    protected declaresAnyCallee(_declaringType: Type.FullyQualified): boolean {
         return false;
     }
 
     /**
      * Override method invocation comparison to include type attribution checking.
-     * When types match semantically, we allow matching even if one has a receiver
-     * and the other doesn't (e.g., `isDate(x)` vs `util.isDate(x)`).
+     * When types match semantically, a call without a receiver matches one with
+     * (e.g., `isDate(x)` vs `util.isDate(x)`).
      */
     override async visitMethodInvocation(method: J.MethodInvocation, other: J): Promise<J | undefined> {
         if (other.kind !== J.Kind.MethodInvocation) {
@@ -2377,28 +2377,10 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         // Check if we can skip name checking based on type attribution
         // We can only skip the name check if both have method types AND they represent the SAME method
         // (not just type-compatible methods, but the actual same function with same FQN)
-        let canSkipNameCheck = false;
-        if (method.methodType && otherMethod.methodType) {
-            // Check if both method types have fully qualified declaring types with the same FQN
-            // This indicates they're the same method from the same module (possibly aliased)
-            const methodDeclaringType = method.methodType.declaringType;
-            const otherDeclaringType = otherMethod.methodType.declaringType;
-
-            if (methodDeclaringType && otherDeclaringType &&
-                Type.isFullyQualified(methodDeclaringType) && Type.isFullyQualified(otherDeclaringType)) {
-
-                const methodFQN = Type.FullyQualified.getFullyQualifiedName(methodDeclaringType as Type.FullyQualified);
-                const otherFQN = Type.FullyQualified.getFullyQualifiedName(otherDeclaringType as Type.FullyQualified);
-
-                // Same module/class AND same method name in the type = same method (can be aliased)
-                if (methodFQN === otherFQN && method.methodType.name === otherMethod.methodType.name) {
-                    canSkipNameCheck = true;
-                }
-                // If FQNs or method names don't match, we can't skip name check - fall through to name checking
-            }
-            // If one or both don't have fully qualified types, we can't safely skip name checking
-            // Fall through to normal name comparison below
-        }
+        // Same module/class AND same method name in the type = same method (can be aliased)
+        const canSkipNameCheck = !!method.methodType && !!otherMethod.methodType &&
+            method.methodType.name === otherMethod.methodType.name &&
+            this.sameFullyQualifiedName(method.methodType.declaringType, otherMethod.methodType.declaringType);
 
         // Check names unless we determined we can skip based on type FQN matching
         if (!canSkipNameCheck) {
@@ -2421,24 +2403,18 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
                 const methodDeclaringType = method.methodType.declaringType;
                 const otherDeclaringType = otherMethod.methodType.declaringType;
 
-                if (methodDeclaringType && otherDeclaringType &&
-                    Type.isFullyQualified(methodDeclaringType) && Type.isFullyQualified(otherDeclaringType)) {
-
-                    const methodFQN = Type.FullyQualified.getFullyQualifiedName(methodDeclaringType as Type.FullyQualified);
-                    const otherFQN = Type.FullyQualified.getFullyQualifiedName(otherDeclaringType as Type.FullyQualified);
-
-                    // Different declaring types = different methods, even with same name
-                    if (methodFQN !== otherFQN) {
-                        return this.valueMismatch('methodType.declaringType');
-                    }
+                // Different declaring types = different methods, even with same name
+                if (Type.isFullyQualified(methodDeclaringType) && Type.isFullyQualified(otherDeclaringType) &&
+                    !this.sameFullyQualifiedName(methodDeclaringType, otherDeclaringType) &&
+                    !this.declaresAnyCallee(methodDeclaringType)) {
+                    return this.valueMismatch('methodType.declaringType');
                 }
             }
         }
 
-        // When types match (canSkipNameCheck = true), we can skip select comparison entirely.
-        // This allows matching forwardRef() vs React.forwardRef() where types indicate same method.
-        if (!canSkipNameCheck || this.selectMustBeVisited(method)) {
-            // Types didn't provide a match - must compare receivers structurally
+        // A written-out receiver still has to match. The method type proves which function
+        // is called, not that the code reads the same.
+        if (!canSkipNameCheck || method.select && !this.functionReceivers(method, otherMethod)) {
             if ((method.select === undefined) !== (otherMethod.select === undefined)) {
                 return this.structuralMismatch('select');
             }
@@ -2448,7 +2424,6 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
                 if (!this.match) return method;
             }
         }
-        // else: types matched, skip select comparison (allows namespace vs named imports)
 
         // A pattern that spells out no type arguments says nothing about them, as with parentheses
         if (method.typeParameters) {
@@ -2505,6 +2480,7 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
      * Override identifier comparison to include:
      * 1. Type checking for field access
      * 2. Semantic equivalence between `undefined` identifier and void expressions
+     * 3. Names that differ but denote one declaration, as an import alias and its export do
      */
     override async visitIdentifier(identifier: J.Identifier, other: J): Promise<J | undefined> {
         // Check if this identifier is "undefined" and the other is a void expression
@@ -2519,9 +2495,8 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
 
         const otherIdentifier = other as J.Identifier;
 
-        // Check name matches
         if (identifier.simpleName !== otherIdentifier.simpleName) {
-            return this.valueMismatch('simpleName');
+            return this.denoteOneDeclaration(identifier, otherIdentifier) ? identifier : this.valueMismatch('simpleName');
         }
 
         // For identifiers with field types, check type attribution
@@ -2540,6 +2515,39 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         return super.visitIdentifier(identifier, other);
     }
 
+    /**
+     * Whether both calls have a bare function-valued receiver, such as a default import of a
+     * callable module. The function type shell names no declaration, so the receivers are told
+     * apart by the call alone.
+     */
+    private functionReceivers(method: J.MethodInvocation, other: J.MethodInvocation): boolean {
+        const isFunctionName = (select?: J.RightPadded<Expression>) =>
+            select?.element.kind === J.Kind.Identifier &&
+            !(select.element as J.Identifier).fieldType &&
+            Type.isFunctionType((select.element as J.Identifier).type);
+        return isFunctionName(method.select) && isFunctionName(other.select);
+    }
+
+    /** An import alias and its export denote one declaration, where a variable holding the same value does not. */
+    private denoteOneDeclaration(identifier: J.Identifier, other: J.Identifier): boolean {
+        if (identifier.fieldType || other.fieldType) {
+            // An unresolved import has the placeholder name `unknown`, which identifies nothing
+            return !!identifier.fieldType && !!other.fieldType &&
+                identifier.fieldType.name === other.fieldType.name && identifier.fieldType.name !== 'unknown' &&
+                this.sameFullyQualifiedName(identifier.fieldType.owner, other.fieldType.owner);
+        }
+        // Only a nominal type names a declaration. The function and object type shells are shared,
+        // and a parameterized type is named after its base alone.
+        return identifier.type?.kind === Type.Kind.Class && other.type?.kind === Type.Kind.Class &&
+            !Type.isFunctionType(identifier.type) && !Type.isObjectType(identifier.type) &&
+            this.sameFullyQualifiedName(identifier.type, other.type);
+    }
+
+    private sameFullyQualifiedName(type?: Type, other?: Type): boolean {
+        return Type.isFullyQualified(type) && Type.isFullyQualified(other) &&
+            Type.FullyQualified.getFullyQualifiedName(type) === Type.FullyQualified.getFullyQualifiedName(other);
+    }
+
     /**
      * Override variable declarations comparison to handle lenient type matching.
      * When lenientTypeMatching is true, patterns without typeExpression can match
@@ -2634,6 +2642,16 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         );
         if (!this.match) return methodDeclaration;
 
+        // Visit name annotations
+        await this.visitArrayProperty(
+            methodDeclaration,
+            'nameAnnotations',
+            methodDeclaration.nameAnnotations,
+            otherMethodDeclaration.nameAnnotations,
+            async (ann1, ann2) => { await this.visit(ann1, ann2); }
+        );
+        if (!this.match) return methodDeclaration;
+
         // Visit type parameters if present
         if (!!methodDeclaration.typeParameters !== !!otherMethodDeclaration.typeParameters) {
             return this.structuralMismatch('typeParameters');
@@ -2742,3 +2760,71 @@ export class JavaScriptSemanticComparatorVisitor extends JavaScriptComparatorVis
         return literal;
     }
 }
+
+/**
+ * Whether two trees are the same code. Whitespace, comments, optional semicolons and trailing
+ * commas, quote style (`'a'` and `"a"`), number spelling (`255` and `0xFF`) and type attribution
+ * do not count. Markers count only where they are syntax that changes meaning, such as `?.`, a non-null
+ * `!`, `function*` and `yield*`, so a marker a recipe attaches does not make trees differ.
+ */
+export async function isEqual(a: J, b: J): Promise<boolean> {
+    return new CodeComparator().compare(a, b);
+}
+
+class CodeComparator extends JavaScriptComparatorVisitor {
+    private readonly meaningfulMarkers: ReadonlySet<string> = new Set([
+        JS.Markers.Optional, JS.Markers.NonNullAssertion, JS.Markers.Generator, JS.Markers.DelegatedYield
+    ]);
+
+    override async visit<R extends J>(j: Tree, p: J, parent?: Cursor): Promise<R | undefined> {
+        if (this.match && this.meaningOf(j as J) !== this.meaningOf(p)) {
+            return this.structuralMismatch('markers') as R;
+        }
+        return super.visit(j, p, parent);
+    }
+
+    protected override async visitProperty(j: any, other: any, propertyName?: string): Promise<any> {
+        if (Type.isType(j) || Type.isType(other)) {
+            return j;
+        }
+        return super.visitProperty(j, other, propertyName);
+    }
+
+    override async visitLiteral(literal: J.Literal, other: J): Promise<J | undefined> {
+        if (!this.match) return literal;
+        const otherLiteral = other as J.Literal;
+        if (denotation(literal) !== denotation(otherLiteral)) {
+            return this.valueMismatch('value', literal.value, otherLiteral.value);
+        }
+        return literal;
+    }
+
+    private meaningOf(tree: J): string {
+        if (!tree.markers?.markers.length) {
+            return '';
+        }
+        return tree.markers.markers
+            .map(marker => marker.kind)
+            .filter(kind => this.meaningfulMarkers.has(kind))
+            .sort()
+            .join(',');
+    }
+}
+
+/**
+ * What a literal stands for, as a comparable key. A regex holds its source text as its value, so it
+ * is told apart from a string by its slashes. A string with a `\uXXXX` surrogate escape holds no
+ * decoded value, so its text between the quotes and its escapes stand in for one.
+ */
+function denotation(literal: J.Literal): string {
+    const source = literal.valueSource ?? '';
+    const primitive = literal.type?.keyword;
+    if (source.startsWith('/')) {
+        return JSON.stringify(['regex', source]);
+    }
+    if (literal.unicodeEscapes) {
+        const quoted = source.startsWith("'") || source.startsWith('"');
+        return JSON.stringify([primitive, quoted ? source.slice(1, -1) : source, literal.unicodeEscapes]);
+    }
+    return JSON.stringify([primitive, literal.value]);
+}

package/src/javascript/format/format.ts

@@ -47,6 +47,15 @@ export const autoFormat = async <J2 extends J, P>(
 ): Promise<J2> =>
     (await new AutoformatVisitor(stopAfter, styles).visit(j, p, parent) as J2);
 
+/** `j` re-indented to the style of the file `parent` leads to, with its other whitespace as it is. */
+export const autoIndent = async <J2 extends J, P>(j: J2, p: P, parent?: Cursor): Promise<J2> => {
+    const styleSource = (isSourceFile(j) ? j : parent?.firstEnclosing(isSourceFile)) ?? j;
+    const tabsAndIndents = getStyle(StyleKind.TabsAndIndentsStyle, styleSource) as TabsAndIndentsStyle;
+    const prettierStyle = getPrettierStyle(j, parent);
+    const style = prettierStyle ? tabsAndIndentsFrom(prettierStyle, tabsAndIndents) : tabsAndIndents;
+    return await new TabsAndIndentsVisitor(style).visit(j, p, parent) as J2;
+}
+
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
  *

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

@@ -179,15 +179,42 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         // 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
         if (tree.kind === JS.Kind.TemplateExpressionSpan) {
-            // Extract base indent from the expression's prefix whitespace (after the last newline)
+            // Whitespace after ${ belongs to the span, not its child expression.
             const span = tree as JS.TemplateExpression.Span;
-            const prefix = span.expression?.prefix?.whitespace ?? "";
+            const prefix = lastWhitespace(span.prefix);
             const lastNewline = prefix.lastIndexOf("\n");
             if (lastNewline >= 0) {
-                return prefix.length - lastNewline - 1;
+                return this.indentWidth(prefix.substring(lastNewline + 1));
+            }
+            const template = this.cursor.parentTree()?.value as JS.TemplateExpression | undefined;
+            if (template?.kind === JS.Kind.TemplateExpression) {
+                const index = template.spans.findIndex(s => s.element.id === span.id);
+                const preceding = index > 0 ? template.spans[index - 1].element.tail : template.head;
+                const text = preceding.valueSource ?? "";
+                const newline = text.lastIndexOf("\n");
+                if (newline >= 0) {
+                    // A span on a literal's own line is anchored to that line's indentation.
+                    const indent = text.substring(newline + 1).match(/^[ \t]*/)?.[0] ?? "";
+                    return this.indentWidth(indent);
+                }
+            }
+            // An inline interpolation continues the surrounding code line, not column zero.
+            for (let c = this.cursor.parent; c; c = c.parent) {
+                const parent = c.value as J;
+                if (parent?.prefix && spaceContainsNewline(parent.prefix)) {
+                    return (c.messages.get("indentContext") as IndentContext | undefined)?.[0] ?? parentMyIndent;
+                }
             }
             return 0;
         }
+        // The tail prefix is the whitespace before }, not another continuation of the expression.
+        const parentTree = this.cursor.parentTree()?.value;
+        if (parentTree?.kind === JS.Kind.TemplateExpressionSpan &&
+            (parentTree as JS.TemplateExpression.Span).tail === tree) {
+            const prefix = lastWhitespace(tree.prefix);
+            const newline = prefix.lastIndexOf("\n");
+            return newline < 0 ? parentMyIndent : this.indentWidth(prefix.substring(newline + 1));
+        }
         if (tree.kind === J.Kind.IfElse || parentIndentKind === 'align') {
             return parentMyIndent;
         }