@openrewrite/rewrite 8.92.17 → 8.92.18

package/src/javascript/add-import.ts

@@ -2,12 +2,14 @@ import {JavaScriptVisitor} from "./visitor";
 import {ElementRemovalFormatter, emptySpace, isIdentifier, J, NameTree, rightPadded, singleSpace, space, Statement, TrailingComma, Type} from "../java";
 import {JS, JSX} from "./tree";
 import {randomId, UUID} from "../uuid";
+import {TypeVisitor} from "../java/type-visitor";
+import {mapAsync, updateIfChanged} from "../util";
+import {packageNameOf} from "./package-name";
 import {emptyMarkers, findMarker, markers, MarkersKind} from "../markers";
 import {NamedStyles} from "../style";
 import {getStyle, SpacesStyle, StyleKind} from "./style";
-import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, isValueReference, namesDeclaredIn, scopeOf, walk} from "./scope";
+import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, namesDeclaredIn, resolve, scopeOf, walk} from "./scope";
 import {create as produce, Draft} from "mutative";
-import {TypeVisitor} from "../java/type-visitor";
 import {autoFormat} from "./format";
 import {getPrettierStyle} from "./format/prettier-format";
 
@@ -90,8 +92,13 @@ export function bindImport(
     // A queued import binds the module as much as one already in the file, so it answers a later
     // request the same way; a name a merged request never emits would be referenced but not bound.
     for (const v of visitor.afterVisit || []) {
+        if (v instanceof RebindImport && !sideEffectOnly && v.to.module === module &&
+            memberName(v.to.member) === memberName(options.member) &&
+            (options.alias === undefined || options.alias === v.boundName)) {
+            return v.boundName;
+        }
         if (!(v instanceof AddImport) || v.module !== module ||
-            v.sideEffectOnly !== sideEffectOnly || v.typeOnly !== typeOnly) {
+            v.sideEffectOnly !== sideEffectOnly || !answersTypeOnly(v.typeOnly, typeOnly)) {
             continue;
         }
         // How a specifier prints, or what name would be nice, does not say which binding is wanted.
@@ -138,7 +145,11 @@ export function bindImport(
     const scope = scopeOf(cursor);
     for (const binding of moduleScopeBindings(cu)) {
         if (binding.module === module && binding.member === memberName(options.member) &&
-            binding.typeOnly === typeOnly && scope.declaringScope(binding.name) === cu) {
+            scope.declaringScope(binding.name) === cu) {
+            if (!answersTypeOnly(binding.typeOnly ?? false, typeOnly)) {
+                // The queued request finds this binding and drops its `type`, so the name stays
+                visitor.afterVisit.push(new AddImport(options, binding.name));
+            }
             return binding.name;
         }
     }
@@ -340,6 +351,56 @@ function requireBindings(pattern: J | undefined, module: string): ModuleScopeBin
         : {name: bound.name, module, member: bound.member, typeOnly: false});
 }
 
+/** Whether a binding answers a request, given which of the two is type-only. A value import binds the type too. */
+function answersTypeOnly(bindingTypeOnly: boolean, requestTypeOnly: boolean): boolean {
+    return requestTypeOnly || !bindingTypeOnly;
+}
+
+/**
+ * `jsImport` binding `member` as a value. A `type` on the member's specifier goes, and one on the
+ * clause moves onto the clause's other specifiers.
+ */
+function asValueImport(jsImport: JS.Import, member: string | undefined): JS.Import {
+    const clause = jsImport.importClause!;
+    const named = clause.namedBindings?.kind === JS.Kind.NamedImports ? clause.namedBindings as JS.NamedImports : undefined;
+    const imports = (specifier: J): boolean =>
+        specifier.kind === JS.Kind.ImportSpecifier && specifierBinding(specifier as JS.ImportSpecifier)?.member === member;
+
+    if (!clause.typeOnly) {
+        return !named ? jsImport : produce(jsImport, draft => {
+            for (const elem of (draft.importClause!.namedBindings as Draft<JS.NamedImports>).elements.elements) {
+                const specifier = elem.element as Draft<JS.ImportSpecifier>;
+                if (member !== undefined && imports(elem.element as J) && specifier.importType.element) {
+                    specifier.specifier.prefix = specifier.importType.before;
+                    specifier.importType = {...specifier.importType, before: emptySpace, element: false};
+                }
+            }
+        });
+    }
+    return produce(jsImport, draft => {
+        const draftClause = draft.importClause!;
+        draftClause.typeOnly = false;
+        // The space after `type` separates nothing once it is gone
+        if (draftClause.name) {
+            draftClause.name.element.prefix = emptySpace;
+        } else if (draftClause.namedBindings) {
+            draftClause.namedBindings.prefix = emptySpace;
+            if (named) {
+                (draftClause.namedBindings as Draft<JS.NamedImports>).elements.before = emptySpace;
+            }
+        }
+        if (named) {
+            for (const elem of (draftClause.namedBindings as Draft<JS.NamedImports>).elements.elements) {
+                const specifier = elem.element as Draft<JS.ImportSpecifier>;
+                if (!imports(elem.element as J) && specifier.kind === JS.Kind.ImportSpecifier) {
+                    specifier.importType = {...specifier.importType, before: emptySpace, element: true};
+                    specifier.specifier.prefix = singleSpace;
+                }
+            }
+        }
+    });
+}
+
 /** The member a specifier imports and the name it binds it under, which are the same absent an alias. */
 function specifierBinding(specifier: JS.ImportSpecifier): { name: string; member: string } | undefined {
     if (specifier.specifier?.kind === J.Kind.Identifier) {
@@ -386,7 +447,8 @@ function importBindings(jsImport: JS.Import): ModuleScopeBinding[] {
                 ? specifierBinding(elem.element as JS.ImportSpecifier)
                 : undefined;
             if (bound) {
-                bindings.push({...bound, module, typeOnly});
+                const specifier = elem.element as JS.ImportSpecifier;
+                bindings.push({...bound, module, typeOnly: typeOnly || specifier.importType.element});
             }
         }
     }
@@ -395,16 +457,17 @@ function importBindings(jsImport: JS.Import): ModuleScopeBinding[] {
 }
 
 /**
- * `names`, plus those pending `AddImport`s on the `afterVisit` queue have claimed. A queued
- * `RemoveImport` does not free one: it removes only what the file leaves unused, and binding a name
- * it keeps is an error, where an unnecessary suffix merely reads oddly.
+ * `names`, plus those pending `AddImport`s and `RebindImport`s on the `afterVisit` queue have
+ * claimed. A queued `RemoveImport` does not free one: it removes only what the file leaves unused,
+ * and binding a name it keeps is an error, where an unnecessary suffix merely reads oddly.
  */
 export function takenNames(names: ReadonlySet<string>, visitor: JavaScriptVisitor<any>): Set<string> {
     const taken = new Set<string>(names);
 
     for (const v of visitor.afterVisit || []) {
-        if (v instanceof AddImport && v.bindingName) {
-            taken.add(v.bindingName);
+        const claimed = claimedName(v);
+        if (claimed) {
+            taken.add(claimed);
         }
     }
 
@@ -413,8 +476,11 @@ export function takenNames(names: ReadonlySet<string>, visitor: JavaScriptVisito
 
 /** As {@link takenNames}, for a caller asking about one name rather than probing repeatedly. */
 export function nameTaken(name: string, names: ReadonlySet<string>, visitor: JavaScriptVisitor<any>): boolean {
-    return names.has(name) ||
-        (visitor.afterVisit || []).some(v => v instanceof AddImport && v.bindingName === name);
+    return names.has(name) || (visitor.afterVisit || []).some(v => claimedName(v) === name);
+}
+
+function claimedName(v: unknown): string | undefined {
+    return v instanceof AddImport ? v.bindingName : v instanceof RebindImport ? v.boundName : undefined;
 }
 
 /**
@@ -866,6 +932,21 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             return compilationUnit;
         }
 
+        // A type-only binding of the member would leave a value use unbound, and a second binding
+        // of the same name would not compile, so the binding the file has loses its `type`
+        if (!this.typeOnly && !this.sideEffectOnly) {
+            const statements = compilationUnit.statements.map(stmt => {
+                const element = stmt.element;
+                return element?.kind === JS.Kind.Import &&
+                    importBindings(element as JS.Import).some(b => b.typeOnly && this.bindsSameName(b))
+                    ? {...stmt, element: asValueImport(element as JS.Import, memberName(this.member))}
+                    : stmt;
+            });
+            if (statements.some((stmt, i) => stmt !== compilationUnit.statements[i])) {
+                return {...compilationUnit, statements} as JS.CompilationUnit;
+            }
+        }
+
         // If onlyIfReferenced is true, check if the identifier is actually used
         // Skip this check for side-effect imports
         if (!this.sideEffectOnly && this.onlyIfReferenced) {
@@ -972,36 +1053,13 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
             if (statement?.kind === JS.Kind.Import) {
                 const jsImport = statement as JS.Import;
-                const moduleSpecifier = jsImport.moduleSpecifier?.element;
-
-                if (!moduleSpecifier) {
-                    continue;
-                }
-
-                const moduleName = this.getModuleName(moduleSpecifier);
-
-                // Check if this is an import from our target module
-                if (moduleName !== this.module) {
-                    continue;
-                }
-
-                const importClause = jsImport.importClause;
-                if (!importClause) {
-                    continue;
-                }
-
-                // Only merge into imports with matching typeOnly - don't mix type and value imports
-                if (importClause.typeOnly !== this.typeOnly) {
+                if (!acceptsNamedMember(jsImport, this.module, this.typeOnly)) {
                     continue;
                 }
+                const importClause = jsImport.importClause!;
 
                 // Case 1: Existing import has named bindings - merge into them
                 if (importClause.namedBindings) {
-                    // Only merge into NamedImports, not namespace imports
-                    if (importClause.namedBindings.kind !== JS.Kind.NamedImports) {
-                        continue;
-                    }
-
                     // We found a matching import with named bindings - merge into it
                     return formatMergedImport(await this.produceJavaScript(compilationUnit, p, async draft => {
                         const namedImports = importClause.namedBindings as JS.NamedImports;
@@ -1102,7 +1160,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
                 // Case 2: Default import without named bindings - add named bindings
                 // Transform: import React from 'react' -> import React, { useState } from 'react'
-                if (importClause.name && !importClause.namedBindings) {
+                if (importClause.name) {
                     return formatMergedImport(await this.produceJavaScript(compilationUnit, p, async draft => {
                         const newSpecifier = this.createImportSpecifier();
 
@@ -1207,9 +1265,13 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
     /** Whether a binding the file already has serves this request. */
     private answeredBy(binding: ModuleScopeBinding): boolean {
+        return this.bindsSameName(binding) && answersTypeOnly(binding.typeOnly ?? false, this.typeOnly);
+    }
+
+    /** Whether `binding` binds this request's member under its name, whether or not it is type-only. */
+    private bindsSameName(binding: ModuleScopeBinding): boolean {
         return binding.module === this.module &&
             binding.member === memberName(this.member) &&
-            binding.typeOnly === this.typeOnly &&
             (this.anyNameAnswers || binding.name === this.bindingName);
     }
 
@@ -1797,6 +1859,13 @@ function namedSpecifierImports(specifier: JS.ImportSpecifier["specifier"], key:
     return false;
 }
 
+/** Whether `imp` binds `member` type-only, by its clause's `type` or the specifier's own. */
+function bindsTypeOnly(imp: JS.Import, member: string | undefined): boolean {
+    const key = memberName(member);
+    return (imp.importClause?.typeOnly ?? false) ||
+        (key !== undefined && key !== '*' && namedSpecifierIsTypeOnly(imp, key));
+}
+
 /** Whether the named specifier binding `key` carries its own inline `type`, as in `{type a, b}`. */
 function namedSpecifierIsTypeOnly(imp: JS.Import, key: string): boolean {
     const namedBindings = imp.importClause?.namedBindings;
@@ -1832,12 +1901,39 @@ function isOnlyMember(jsImport: JS.Import): boolean {
     return (hasDefault ? 1 : 0) + (hasNamespace ? 1 : 0) + namedImportCount(jsImport) === 1;
 }
 
+function importedModule(jsImport: JS.Import): string | undefined {
+    const specifier = jsImport.moduleSpecifier?.element;
+    return jsImport.importClause !== undefined && specifier?.kind === J.Kind.Literal
+        ? moduleNameOf(specifier as J.Literal)
+        : undefined;
+}
+
+/** Whether `AddImport` merges a named member of `module` into `jsImport` rather than adding a statement. */
+function acceptsNamedMember(jsImport: JS.Import, module: string, typeOnly: boolean): boolean {
+    const clause = jsImport.importClause;
+    const specifier = jsImport.moduleSpecifier?.element;
+    if (!clause || clause.typeOnly !== typeOnly || specifier?.kind !== J.Kind.Literal ||
+        moduleNameOf(specifier as J.Literal) !== module) {
+        return false;
+    }
+    return clause.namedBindings ? clause.namedBindings.kind === JS.Kind.NamedImports : clause.name !== undefined;
+}
+
+/** Which of an import clause's three slots `member` binds — `import`, `import *`, or `import {}`. */
+export function bindingShape(member: string | undefined): "default" | "namespace" | "named" {
+    const key = memberName(member);
+    return key === undefined ? "default" : key === "*" ? "namespace" : "named";
+}
+
 export interface ExistingImportBinding {
     localName: string;
     onlyMemberOfStatement: boolean;
 
     /** Whether the source states this local name — `import {a as b}` — or takes it from the member. */
     aliased: boolean;
+
+    /** Whether the clause or the specifier itself is marked `type`. */
+    typeOnly: boolean;
 }
 
 /**
@@ -1859,7 +1955,8 @@ export function existingImportBinding(
             return {
                 localName,
                 onlyMemberOfStatement: isOnlyMember(element as JS.Import),
-                aliased: localName !== memberName(member)
+                aliased: localName !== memberName(member),
+                typeOnly: bindsTypeOnly(element as JS.Import, member)
             };
         }
     }
@@ -1961,11 +2058,44 @@ function removeBinding(jsImport: JS.Import, member: string | undefined): JS.Impo
     return {...jsImport, importClause: {...importClause, namedBindings: updatedNamedImports}};
 }
 
+/** `cu` without the statement `id`, its prefix carried onto the next one so a file header survives. */
+function withoutStatement(cu: JS.CompilationUnit, id: UUID): JS.CompilationUnit {
+    const formatter = new ElementRemovalFormatter<J>(true);
+    const statements: J.RightPadded<Statement>[] = [];
+    for (const stmt of cu.statements) {
+        if (stmt.element?.id === id) {
+            formatter.markRemoved(stmt.element);
+        } else {
+            const kept = stmt.element && formatter.processKept(stmt.element) as Statement;
+            statements.push(kept === stmt.element ? stmt : {...stmt, element: kept!});
+        }
+    }
+    return {...cu, statements};
+}
+
 /**
- * Moves the binding `from` names to `to`, binding it under `boundName`. In place when the
- * statement that carries it binds nothing else — module and member specifier rewritten there
- * directly; otherwise the old specifier drops and {@link bindImport} queues the replacement.
- * A `boundName` of its own renames the binding, and the file's references to it follow.
+ * Whether moving the only binding of `jsImport` to `to` replaces the statement rather than rewriting
+ * it in place. A different shape needs a different clause, and another import of `to` takes it in.
+ */
+function replacesStatement(
+    cu: JS.CompilationUnit,
+    jsImport: JS.Import,
+    from: {member?: string},
+    to: {module: string; member?: string},
+    typeOnly: boolean
+): boolean {
+    const shape = bindingShape(to.member);
+    return shape !== bindingShape(from.member) || (shape === "named" && cu.statements.some(s =>
+        s.element !== jsImport && s.element?.kind === JS.Kind.Import &&
+        acceptsNamedMember(s.element as JS.Import, to.module, typeOnly)));
+}
+
+const esmStyle = {default: ImportStyle.ES6Default, namespace: ImportStyle.ES6Namespace, named: ImportStyle.ES6Named};
+
+/**
+ * Moves the binding `from` names to `to`, binding it under `boundName`, and the file's references
+ * follow a `boundName` of its own. Whether the statement is rewritten in place or replaced is decided
+ * when this visitor runs, because a sibling rebind may empty the statement first.
  *
  * Not built on `RemoveImport`/`maybeUnbind`: those only drop a binding once nothing references
  * it, but a rebind moves one that is still in use — removal here has to be unconditional.
@@ -1982,23 +2112,46 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
 
     private transformedInPlace = false;
     private typeOnly = false;
-    private readonly movedTypes = new MovedTypes(this.from, this.to);
-    /** Identifiers settled as references to the binding, so a parent need not settle it again. */
-    private readonly references = new Set<string>();
+    private cu?: JS.CompilationUnit;
+    private dropped?: UUID;
+    private droppedQuote?: QuoteChar;
+    private movedTypes!: MovedTypes;
 
     private get renaming(): boolean {
         return this.boundName !== this.localName;
     }
 
     override async visitJsCompilationUnit(cu: JS.CompilationUnit, p: P): Promise<J | undefined> {
-        const visited = await super.visitJsCompilationUnit(cu, p) as JS.CompilationUnit;
+        this.cu = cu;
+        const imports = cu.statements
+            .filter(s => s.element?.kind === JS.Kind.Import)
+            .map(s => s.element as JS.Import);
+        const ofModule = imports.filter(imp => importedModule(imp) === this.from.module);
+        const fromPackage = packageOf(this.from.module);
+        const member = declaredMember(this.from);
+        this.movedTypes = new MovedTypes(this.from, this.to, {
+            module: ofModule.length > 1 || ofModule.some(imp => !isOnlyMember(imp)),
+            // Same-named classes from two subpaths of one package share a name.
+            className: member !== undefined && imports.filter(imp => {
+                const module = importedModule(imp);
+                return module !== undefined && packageOf(module) === fromPackage &&
+                    importBinds(imp, module, member) !== undefined;
+            }).length > 1
+        });
+        let visited = await super.visitJsCompilationUnit(cu, p) as JS.CompilationUnit;
+        if (this.dropped !== undefined) {
+            visited = withoutStatement(visited, this.dropped);
+        }
         if (!this.transformedInPlace) {
             bindImport(this, {
                 module: this.to.module,
                 member: this.to.member,
                 alias: this.boundName,
                 typeOnly: this.typeOnly,
-                onlyIfReferenced: false
+                onlyIfReferenced: false,
+                quoteStyle: this.droppedQuote,
+                // The binding was an ES import, though the file may no longer read as a module without it.
+                style: esmStyle[bindingShape(this.to.member)]
             });
         }
         return visited;
@@ -2008,19 +2161,24 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
         const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
 
         const key = memberName(this.from.member);
-        // One call moves one binding, and no two imports bind the same local name, so the name
-        // read from the matched statement is what picks it back out of the file.
-        if (importBinds(imp, this.from.module, this.from.member) !== this.localName) {
+        // One call moves one module-scope binding, and no two of those share a local name, so the
+        // name read from the matched statement is what picks it back out of the file.
+        const cu = this.cu;
+        if (!cu?.statements.some(s => s.element === jsImport) ||
+            importBinds(imp, this.from.module, this.from.member) !== this.localName) {
             return imp;
         }
-        // A moved named specifier's own inline `type` marks it type-only even where the clause
-        // it's leaving is not — the replacement needs the same answer to stay type-safe.
-        this.typeOnly = (imp.importClause?.typeOnly ?? false) ||
-            (key !== undefined && key !== '*' && namedSpecifierIsTypeOnly(imp, key));
+        // The replacement takes the moved binding's `type` marking to stay type-safe.
+        this.typeOnly = bindsTypeOnly(imp, this.from.member);
 
         if (!isOnlyMember(imp)) {
             return removeBinding(imp, this.from.member);
         }
+        if (replacesStatement(cu, jsImport, this.from, this.to, this.typeOnly)) {
+            this.dropped = imp.id;
+            this.droppedQuote = quoteOf(imp.moduleSpecifier?.element);
+            return imp;
+        }
 
         this.transformedInPlace = true;
         return produce(imp, draft => {
@@ -2044,56 +2202,14 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
     }
 
     override async visitIdentifier(identifier: J.Identifier, p: P): Promise<J | undefined> {
-        if (!this.referencesBinding(identifier)) {
-            return super.visitIdentifier(identifier, p);
-        }
-        this.references.add(identifier.id);
-        // The name follows the binding, and so does what the name is attributed to; an aliased
-        // binding keeps its name and still resolves somewhere new.
-        const type = await this.movedTypes.visit(identifier.type, undefined);
-        const fieldType = await this.movedTypes.visit(identifier.fieldType, undefined) as Type.Variable | undefined;
-        return !this.renaming && type === identifier.type && fieldType === identifier.fieldType
-            ? identifier
-            : {...identifier, simpleName: this.boundName, type, fieldType} as J.Identifier;
-    }
-
-    override async visitMethodInvocation(method: J.MethodInvocation, p: P): Promise<J | undefined> {
-        const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
-        if (!this.referencesMovedBinding(m.name)) {
-            return m;
-        }
-        const methodType = await this.movedTypes.visit(m.methodType, undefined) as Type.Method | undefined;
-        return methodType === m.methodType ? m : {...m, methodType} as J.MethodInvocation;
-    }
-
-    override async visitNewClass(newClass: J.NewClass, p: P): Promise<J | undefined> {
-        const nc = await super.visitNewClass(newClass, p) as J.NewClass;
-        if (!this.referencesMovedBinding(nc.class)) {
-            return nc;
-        }
-        const type = await this.movedTypes.visit(nc.type, undefined);
-        const methodType = await this.movedTypes.visit(nc.methodType, undefined) as Type.Method | undefined;
-        const constructorType = await this.movedTypes.visit(nc.constructorType, undefined) as Type.Method | undefined;
-        return type === nc.type && methodType === nc.methodType && constructorType === nc.constructorType
-            ? nc
-            : {...nc, type, methodType, constructorType} as J.NewClass;
-    }
-
-    override async visitFunctionCall(functionCall: JS.FunctionCall, p: P): Promise<J | undefined> {
-        const fc = await super.visitFunctionCall(functionCall, p) as JS.FunctionCall;
-        if (!this.referencesMovedBinding(fc.function?.element)) {
-            return fc;
-        }
-        const methodType = await this.movedTypes.visit(fc.methodType, undefined) as Type.Method | undefined;
-        return methodType === fc.methodType ? fc : {...fc, methodType} as JS.FunctionCall;
+        const renamed = this.renaming && this.referencesBinding(identifier);
+        const visited = await super.visitIdentifier(identifier, p) as J.Identifier;
+        return renamed ? {...visited, simpleName: this.boundName} as J.Identifier : visited;
     }
 
-    /**
-     * Whether `callee` is the identifier `visitIdentifier` settled as a reference to the binding.
-     * A rewrite keeps the identifier's id, so the one it settled is the one still standing here.
-     */
-    private referencesMovedBinding(callee: J | undefined): boolean {
-        return callee?.kind === J.Kind.Identifier && this.references.has(callee.id);
+    /** Any type in the file can name what moved, whether or not it references the binding. */
+    protected override async visitType(javaType: Type | undefined, p: P): Promise<Type | undefined> {
+        return this.movedTypes.visit(javaType, undefined);
     }
 
     /**
@@ -2120,7 +2236,14 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
         }
         const specifier = exportSpecifier.specifier;
         if (specifier.kind === J.Kind.Identifier && (specifier as J.Identifier).simpleName === this.localName) {
-            return {...exportSpecifier, specifier: aliasing(specifier as J.Identifier, this.boundName)} as JS.ExportSpecifier;
+            const retyped = await this.retyped(specifier as J.Identifier);
+            const alias = aliasing(retyped, this.boundName);
+            // The property name is the reference here, so it carries the binding's attribution.
+            const reference = {...alias.propertyName.element, type: retyped.type, fieldType: retyped.fieldType};
+            return {
+                ...exportSpecifier,
+                specifier: {...alias, propertyName: {...alias.propertyName, element: reference}}
+            } as JS.ExportSpecifier;
         }
         if (specifier.kind === JS.Kind.Alias) {
             const alias = specifier as JS.Alias;
@@ -2130,7 +2253,10 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
                     ...exportSpecifier,
                     specifier: {
                         ...alias,
-                        propertyName: {...alias.propertyName, element: {...propertyName, simpleName: this.boundName}}
+                        propertyName: {
+                            ...alias.propertyName,
+                            element: {...await this.retyped(propertyName as J.Identifier), simpleName: this.boundName}
+                        }
                     }
                 } as JS.ExportSpecifier
                 : exportSpecifier;
@@ -2138,64 +2264,105 @@ export class RebindImport<P> extends JavaScriptVisitor<P> {
         return super.visitExportSpecifier(exportSpecifier, p);
     }
 
+    /** `identifier` attributed to what moved, for a rewrite that does not visit it again. */
+    private async retyped(identifier: J.Identifier): Promise<J.Identifier> {
+        return {
+            ...identifier,
+            type: await this.movedTypes.visit(identifier.type, undefined),
+            fieldType: await this.movedTypes.visit(identifier.fieldType, undefined)
+        };
+    }
+
     /**
      * Whether the identifier at the cursor stands for the moved binding: the right name, in a
-     * position that references rather than declares, reaching the module scope that binds it.
+     * position a rename may rewrite, resolving to the module scope that binds it.
      */
     private referencesBinding(identifier: J.Identifier): boolean {
-        return identifier.simpleName === this.localName &&
-            // The specifier binding the name is the one edit that is not a reference to it.
-            !this.cursor.firstEnclosing((v): v is JS.Import => (v as J | undefined)?.kind === JS.Kind.Import) &&
-            isValueReference(this.cursor, identifier) &&
-            scopeOf(this.cursor).declaringScope(this.localName)?.kind === JS.Kind.CompilationUnit;
+        return identifier.simpleName === this.localName && this.readsModuleBinding(identifier);
+    }
+
+    private readsModuleBinding(identifier: J.Identifier): boolean {
+        return resolve(this.cursor, identifier)?.kind === JS.Kind.CompilationUnit;
     }
 
-    /** A shorthand property's name slot is also the reference to the binding. */
+    /**
+     * A shorthand property's name slot is also the reference to the binding: `{x}` becomes
+     * `{x: y}`, and `{x = 1}` becomes `{x: y = 1}`.
+     */
     override async visitPropertyAssignment(propertyAssignment: JS.PropertyAssignment, p: P): Promise<J | undefined> {
         const name = propertyAssignment.name.element;
-        if (this.renaming && propertyAssignment.initializer === undefined &&
+        if (this.renaming && propertyAssignment.assigmentToken === JS.PropertyAssignment.Token.Equals &&
             name.kind === J.Kind.Identifier && (name as J.Identifier).simpleName === this.localName &&
-            scopeOf(this.cursor).declaringScope(this.localName)?.kind === JS.Kind.CompilationUnit) {
-            // The key names a property rather than the binding, so it carries no attribution,
-            // the same way `aliasing` builds a property name that stands for nothing.
+            this.readsModuleBinding(name as J.Identifier)) {
+            const reference: J.Identifier = {...await this.retyped(name as J.Identifier), simpleName: this.boundName};
+            const fallback = propertyAssignment.initializer;
+            // The key names a property rather than the binding, so it is a new node carrying no
+            // attribution, the same way `aliasing` builds a property name that stands for nothing.
             return {
                 ...propertyAssignment,
-                name: {...propertyAssignment.name, element: {...name, type: undefined, fieldType: undefined}},
+                name: {
+                    ...propertyAssignment.name,
+                    element: {...name, id: randomId(), type: undefined, fieldType: undefined},
+                    after: emptySpace
+                },
                 assigmentToken: JS.PropertyAssignment.Token.Colon,
-                initializer: {...(name as J.Identifier), prefix: singleSpace, simpleName: this.boundName}
+                initializer: fallback === undefined ? {...reference, prefix: singleSpace} : {
+                    id: randomId(),
+                    kind: J.Kind.Assignment,
+                    prefix: singleSpace,
+                    markers: emptyMarkers,
+                    variable: {...reference, prefix: emptySpace},
+                    assignment: {
+                        kind: J.Kind.LeftPadded,
+                        before: propertyAssignment.name.after,
+                        element: fallback,
+                        markers: emptyMarkers
+                    },
+                    type: reference.type
+                } as J.Assignment
             } as JS.PropertyAssignment;
         }
         return super.visitPropertyAssignment(propertyAssignment, p);
     }
 }
 
-/**
- * Rewrites the attribution a move invalidates, onto the module and member it moved to. Applied at
- * a reference to the moved binding. See CLAUDE.md: What a rebind's attribution follows.
- */
+/** Rewrites a file's attribution onto the module and member a binding moved to. */
 class MovedTypes extends TypeVisitor<undefined> {
     private readonly onPath = new Set<Type>();
     private readonly answered = new Map<Type, Type | undefined>();
-    private readonly renamed: ReadonlyMap<string, string>;
+    private readonly modules = new Map<Type, Type.FullyQualified>();
+    private readonly classes: ReadonlyMap<string, string>;
     private readonly fromMember?: string;
     private readonly toMember?: string;
-    private readonly toModule: string;
 
-    constructor(from: {module: string; member?: string}, to: {module: string; member?: string}) {
+    /**
+     * `shared` says what another binding in the file shares with the moved one. A shared module
+     * object or package-qualified class name stands for that binding too, so it keeps its name.
+     */
+    constructor(
+        private readonly from: {module: string; member?: string},
+        private readonly to: {module: string; member?: string},
+        shared: {module: boolean; className: boolean}
+    ) {
         super();
-        // Where no member is named the two keys coincide, and both name the module.
-        this.renamed = new Map([[from.module, to.module], [qualifiedName(from), qualifiedName(to)]]);
         this.fromMember = declaredMember(from);
         this.toMember = declaredMember(to);
-        this.toModule = to.module;
+        if (this.fromMember === undefined) {
+            this.classes = new Map(shared.module ? [] : [[from.module, qualifiedName(to)]]);
+        } else {
+            // A default export declares no member name, so the class keeps its own.
+            const toClass = `${packageOf(to.module)}.${this.toMember ?? this.fromMember}`;
+            const packaged = `${packageOf(from.module)}.${this.fromMember}`;
+            // The type mapper names an imported alias symbol after the specifier.
+            this.classes = new Map([packaged, qualifiedName(from)]
+                .filter(name => !shared.className || name !== packaged)
+                .map(name => [name, toClass]));
+        }
     }
 
     /**
-     * A type reached while it is still being visited is a cycle — a class holds a method whose
-     * declaring type is that class — and answers with itself, which is what ends the walk. Every
-     * type visited is remembered by its answer, so a graph whose references fan out or rejoin is
-     * walked once rather than once per path that reaches into it. An answer settled inside a cycle
-     * stands for the path it was on, so a walk reusing it can leave a rename unapplied.
+     * A type reached while it is still being visited answers with itself, which ends a cycle
+     * through a type variable's bounds. An answer settled inside such a cycle can miss a rename.
      */
     override async visit<T extends Type>(type: T | undefined, p: undefined): Promise<T | undefined> {
         if (type === undefined || this.onPath.has(type)) {
@@ -2214,38 +2381,57 @@ class MovedTypes extends TypeVisitor<undefined> {
         }
     }
 
+    /** A class's members are left out, which keeps the walk to a type's signature, as in Java's `ChangeType`. */
     protected override async visitClass(aClass: Type.Class, p: undefined): Promise<Type | undefined> {
-        const visited = await super.visitClass(aClass, p) as Type.Class;
-        const moved = this.renamed.get(visited.fullyQualifiedName);
-        return moved === undefined || moved === visited.fullyQualifiedName
-            ? visited
-            : {...visited, fullyQualifiedName: moved} as Type.Class;
+        const visited = updateIfChanged(aClass, {
+            supertype: await this.visit(aClass.supertype, p),
+            owningClass: await this.visit(aClass.owningClass, p),
+            interfaces: aClass.interfaces && await mapAsync(aClass.interfaces, i => this.visit(i, p)),
+            typeParameters: aClass.typeParameters && await mapAsync(aClass.typeParameters, t => this.visit(t, p))
+        });
+        const moved = this.classes.get(visited.fullyQualifiedName);
+        return moved === undefined ? visited : {...visited, fullyQualifiedName: moved} as Type.Class;
     }
 
     protected override async visitMethod(method: Type.Method, p: undefined): Promise<Type | undefined> {
         const visited = await super.visitMethod(method, p) as Type.Method;
-        return this.declaresMovedMember(visited.name, visited.declaringType)
-            ? {...visited, name: this.toMember} as Type.Method
-            : visited;
+        if (!this.isMovedMember(method.name, method.declaringType)) {
+            return visited;
+        }
+        const declaringType = this.movedModule(method.declaringType);
+        return {...visited, declaringType, name: this.toMember ?? visited.name} as Type.Method;
     }
 
     protected override async visitVariable(variable: Type.Variable, p: undefined): Promise<Type | undefined> {
         const visited = await super.visitVariable(variable, p) as Type.Variable;
-        return this.declaresMovedMember(visited.name, visited.owner)
-            ? {...visited, name: this.toMember} as Type.Variable
-            : visited;
+        if (!this.isMovedMember(variable.name, variable.owner)) {
+            return visited;
+        }
+        return {...visited, owner: this.movedModule(variable.owner!), name: this.toMember ?? visited.name} as Type.Variable;
     }
 
     /**
-     * Whether `name`, declared on `owner`, is the member that moved. `owner` has already followed
-     * the move by the time this runs, so it is the module moved *to* that it has to name. A
-     * default or namespace binding declares no member, so there is no name for one to take.
+     * Whether `name` is the moved member as the module object `owner` declares it. That covers a
+     * function, a constant and a moved class's constructor. A sibling declared beside it is not one.
      */
-    private declaresMovedMember(name: string, owner: Type | undefined): boolean {
-        return this.toMember !== undefined && name === this.fromMember && this.toMember !== this.fromMember &&
-            owner !== undefined && Type.isFullyQualified(owner) &&
-            Type.FullyQualified.getFullyQualifiedName(owner) === this.toModule;
+    private isMovedMember(name: string, owner: Type | undefined): boolean {
+        return this.fromMember !== undefined && name === this.fromMember && owner !== undefined &&
+            Type.isFullyQualified(owner) && Type.FullyQualified.getFullyQualifiedName(owner) === this.from.module;
     }
+
+    private movedModule(owner: Type): Type.FullyQualified {
+        let moved = this.modules.get(owner);
+        if (moved === undefined) {
+            moved = {...owner, fullyQualifiedName: this.to.module} as Type.FullyQualified;
+            this.modules.set(owner, moved);
+        }
+        return moved;
+    }
+}
+
+/** The package a class `module` exports is named after. A relative specifier names none, so it stands for itself. */
+function packageOf(module: string): string {
+    return module.startsWith('.') || module.startsWith('/') ? module : packageNameOf(module);
 }
 
 /** A member's qualified name, or the module's own where no member is named. */