@openrewrite/rewrite 8.92.16 → 8.92.18

package/dist/javascript/add-import.js

@@ -11,16 +11,19 @@ exports.requiredModuleOf = requiredModuleOf;
 exports.takenNames = takenNames;
 exports.nameTaken = nameTaken;
 exports.moduleNameOf = moduleNameOf;
+exports.bindingShape = bindingShape;
 exports.existingImportBinding = existingImportBinding;
 const visitor_1 = require("./visitor");
 const java_1 = require("../java");
 const tree_1 = require("./tree");
 const uuid_1 = require("../uuid");
+const type_visitor_1 = require("../java/type-visitor");
+const util_1 = require("../util");
+const package_name_1 = require("./package-name");
 const markers_1 = require("../markers");
 const style_1 = require("./style");
 const scope_1 = require("./scope");
 const mutative_1 = require("mutative");
-const type_visitor_1 = require("../java/type-visitor");
 const format_1 = require("./format");
 const prettier_format_1 = require("./format/prettier-format");
 var ImportStyle;
@@ -37,7 +40,7 @@ var ImportStyle;
  * without affecting whether an existing binding answers the request first.
  */
 function bindImport(visitor, options, refuseCreate) {
-    var _a, _b;
+    var _a, _b, _c;
     validate(options);
     const module = moduleNameOf(options.module);
     const sideEffectOnly = (_a = options.sideEffectOnly) !== null && _a !== void 0 ? _a : false;
@@ -45,8 +48,13 @@ function bindImport(visitor, options, refuseCreate) {
     // 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.
@@ -89,7 +97,11 @@ function bindImport(visitor, options, refuseCreate) {
     const scope = (0, scope_1.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((_c = binding.typeOnly) !== null && _c !== void 0 ? _c : 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;
         }
     }
@@ -266,6 +278,54 @@ function requireBindings(pattern, module) {
         ? { name: bound.name }
         : { 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, requestTypeOnly) {
+    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, member) {
+    var _a;
+    const clause = jsImport.importClause;
+    const named = ((_a = clause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.NamedImports ? clause.namedBindings : undefined;
+    const imports = (specifier) => { var _a; return specifier.kind === tree_1.JS.Kind.ImportSpecifier && ((_a = specifierBinding(specifier)) === null || _a === void 0 ? void 0 : _a.member) === member; };
+    if (!clause.typeOnly) {
+        return !named ? jsImport : (0, mutative_1.create)(jsImport, draft => {
+            for (const elem of draft.importClause.namedBindings.elements.elements) {
+                const specifier = elem.element;
+                if (member !== undefined && imports(elem.element) && specifier.importType.element) {
+                    specifier.specifier.prefix = specifier.importType.before;
+                    specifier.importType = Object.assign(Object.assign({}, specifier.importType), { before: java_1.emptySpace, element: false });
+                }
+            }
+        });
+    }
+    return (0, mutative_1.create)(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 = java_1.emptySpace;
+        }
+        else if (draftClause.namedBindings) {
+            draftClause.namedBindings.prefix = java_1.emptySpace;
+            if (named) {
+                draftClause.namedBindings.elements.before = java_1.emptySpace;
+            }
+        }
+        if (named) {
+            for (const elem of draftClause.namedBindings.elements.elements) {
+                const specifier = elem.element;
+                if (!imports(elem.element) && specifier.kind === tree_1.JS.Kind.ImportSpecifier) {
+                    specifier.importType = Object.assign(Object.assign({}, specifier.importType), { before: java_1.emptySpace, element: true });
+                    specifier.specifier.prefix = java_1.singleSpace;
+                }
+            }
+        }
+    });
+}
 /** The member a specifier imports and the name it binds it under, which are the same absent an alias. */
 function specifierBinding(specifier) {
     var _a, _b, _c, _d, _e;
@@ -312,30 +372,34 @@ function importBindings(jsImport) {
                 ? specifierBinding(elem.element)
                 : undefined;
             if (bound) {
-                bindings.push(Object.assign(Object.assign({}, bound), { module, typeOnly }));
+                const specifier = elem.element;
+                bindings.push(Object.assign(Object.assign({}, bound), { module, typeOnly: typeOnly || specifier.importType.element }));
             }
         }
     }
     return bindings;
 }
 /**
- * `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.
  */
 function takenNames(names, visitor) {
     const taken = new Set(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);
         }
     }
     return taken;
 }
 /** As {@link takenNames}, for a caller asking about one name rather than probing repeatedly. */
 function nameTaken(name, names, visitor) {
-    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) {
+    return v instanceof AddImport ? v.bindingName : v instanceof RebindImport ? v.boundName : undefined;
 }
 /**
  * The parser lifts surrogate pairs out of `valueSource` into `unicodeEscapes` and, when it does,
@@ -733,6 +797,19 @@ class AddImport extends visitor_1.JavaScriptVisitor {
         if (hasImport) {
             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 === null || element === void 0 ? void 0 : element.kind) === tree_1.JS.Kind.Import &&
+                    importBindings(element).some(b => b.typeOnly && this.bindsSameName(b))
+                    ? Object.assign(Object.assign({}, stmt), { element: asValueImport(element, memberName(this.member)) }) : stmt;
+            });
+            if (statements.some((stmt, i) => stmt !== compilationUnit.statements[i])) {
+                return Object.assign(Object.assign({}, compilationUnit), { statements });
+            }
+        }
         // If onlyIfReferenced is true, check if the identifier is actually used
         // Skip this check for side-effect imports
         if (!this.sideEffectOnly && this.onlyIfReferenced) {
@@ -816,35 +893,17 @@ class AddImport extends visitor_1.JavaScriptVisitor {
      * Try to merge the new member into an existing import from the same module
      */
     async tryMergeIntoExistingImport(compilationUnit, p) {
-        var _a;
         for (let i = 0; i < compilationUnit.statements.length; i++) {
             const stmt = compilationUnit.statements[i];
             const statement = stmt.element;
             if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
                 const jsImport = statement;
-                const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
-                if (!moduleSpecifier) {
-                    continue;
-                }
-                const moduleName = this.getModuleName(moduleSpecifier);
-                // Check if this is an import from our target module
-                if (moduleName !== this.module) {
+                if (!acceptsNamedMember(jsImport, this.module, this.typeOnly)) {
                     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) {
-                    continue;
-                }
                 // Case 1: Existing import has named bindings - merge into them
                 if (importClause.namedBindings) {
-                    // Only merge into NamedImports, not namespace imports
-                    if (importClause.namedBindings.kind !== tree_1.JS.Kind.NamedImports) {
-                        continue;
-                    }
                     // We found a matching import with named bindings - merge into it
                     return formatMergedImport(await this.produceJavaScript(compilationUnit, p, async (draft) => {
                         var _a, _b, _c, _d, _e, _f;
@@ -919,7 +978,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 }
                 // 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();
                         // Get the spaces style for brace spacing
@@ -1004,9 +1063,13 @@ class AddImport extends visitor_1.JavaScriptVisitor {
     }
     /** Whether a binding the file already has serves this request. */
     answeredBy(binding) {
+        var _a;
+        return this.bindsSameName(binding) && answersTypeOnly((_a = binding.typeOnly) !== null && _a !== void 0 ? _a : false, this.typeOnly);
+    }
+    /** Whether `binding` binds this request's member under its name, whether or not it is type-only. */
+    bindsSameName(binding) {
         return binding.module === this.module &&
             binding.member === memberName(this.member) &&
-            binding.typeOnly === this.typeOnly &&
             (this.anyNameAnswers || binding.name === this.bindingName);
     }
     /**
@@ -1551,6 +1614,13 @@ function namedSpecifierImports(specifier, key) {
     }
     return false;
 }
+/** Whether `imp` binds `member` type-only, by its clause's `type` or the specifier's own. */
+function bindsTypeOnly(imp, member) {
+    var _a, _b;
+    const key = memberName(member);
+    return ((_b = (_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.typeOnly) !== null && _b !== void 0 ? _b : 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, key) {
     var _a;
@@ -1586,6 +1656,29 @@ function isOnlyMember(jsImport) {
     const hasNamespace = ((_a = importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.Alias;
     return (hasDefault ? 1 : 0) + (hasNamespace ? 1 : 0) + namedImportCount(jsImport) === 1;
 }
+function importedModule(jsImport) {
+    var _a;
+    const specifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+    return jsImport.importClause !== undefined && (specifier === null || specifier === void 0 ? void 0 : specifier.kind) === java_1.J.Kind.Literal
+        ? moduleNameOf(specifier)
+        : undefined;
+}
+/** Whether `AddImport` merges a named member of `module` into `jsImport` rather than adding a statement. */
+function acceptsNamedMember(jsImport, module, typeOnly) {
+    var _a;
+    const clause = jsImport.importClause;
+    const specifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+    if (!clause || clause.typeOnly !== typeOnly || (specifier === null || specifier === void 0 ? void 0 : specifier.kind) !== java_1.J.Kind.Literal ||
+        moduleNameOf(specifier) !== module) {
+        return false;
+    }
+    return clause.namedBindings ? clause.namedBindings.kind === tree_1.JS.Kind.NamedImports : clause.name !== undefined;
+}
+/** Which of an import clause's three slots `member` binds — `import`, `import *`, or `import {}`. */
+function bindingShape(member) {
+    const key = memberName(member);
+    return key === undefined ? "default" : key === "*" ? "namespace" : "named";
+}
 /**
  * The existing binding for `member` of `module`, read from `cu`'s own import statements — what
  * `maybeRebind` reads before committing to a `RebindImport` edit.
@@ -1601,7 +1694,8 @@ function existingImportBinding(cu, module, member) {
             return {
                 localName,
                 onlyMemberOfStatement: isOnlyMember(element),
-                aliased: localName !== memberName(member)
+                aliased: localName !== memberName(member),
+                typeOnly: bindsTypeOnly(element, member)
             };
         }
     }
@@ -1696,11 +1790,39 @@ function removeBinding(jsImport, member) {
     const updatedNamedImports = Object.assign(Object.assign({}, namedImports), { elements: Object.assign(Object.assign({}, namedImports.elements), { elements: kept }) });
     return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: updatedNamedImports }) });
 }
+/** `cu` without the statement `id`, its prefix carried onto the next one so a file header survives. */
+function withoutStatement(cu, id) {
+    var _a;
+    const formatter = new java_1.ElementRemovalFormatter(true);
+    const statements = [];
+    for (const stmt of cu.statements) {
+        if (((_a = stmt.element) === null || _a === void 0 ? void 0 : _a.id) === id) {
+            formatter.markRemoved(stmt.element);
+        }
+        else {
+            const kept = stmt.element && formatter.processKept(stmt.element);
+            statements.push(kept === stmt.element ? stmt : Object.assign(Object.assign({}, stmt), { element: kept }));
+        }
+    }
+    return Object.assign(Object.assign({}, cu), { statements });
+}
+/**
+ * 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, jsImport, from, to, typeOnly) {
+    const shape = bindingShape(to.member);
+    return shape !== bindingShape(from.member) || (shape === "named" && cu.statements.some(s => {
+        var _a;
+        return s.element !== jsImport && ((_a = s.element) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.Import &&
+            acceptsNamedMember(s.element, 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`. 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.
+ * 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.
@@ -1714,42 +1836,66 @@ class RebindImport extends visitor_1.JavaScriptVisitor {
         this.boundName = boundName;
         this.transformedInPlace = false;
         this.typeOnly = false;
-        this.movedTypes = new MovedTypes(this.from, this.to);
-        /** Identifiers settled as references to the binding, so a parent need not settle it again. */
-        this.references = new Set();
     }
     get renaming() {
         return this.boundName !== this.localName;
     }
     async visitJsCompilationUnit(cu, p) {
-        const visited = await super.visitJsCompilationUnit(cu, p);
+        this.cu = cu;
+        const imports = cu.statements
+            .filter(s => { var _a; return ((_a = s.element) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.Import; })
+            .map(s => s.element);
+        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);
+        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;
     }
     async visitImportDeclaration(jsImport, p) {
-        var _a, _b;
+        var _a;
         const imp = await super.visitImportDeclaration(jsImport, p);
         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 === null || cu === void 0 ? void 0 : 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 = ((_b = (_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.typeOnly) !== null && _b !== void 0 ? _b : 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((_a = imp.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element);
+            return imp;
+        }
         this.transformedInPlace = true;
         return (0, mutative_1.create)(imp, draft => {
             var _a;
@@ -1771,53 +1917,13 @@ class RebindImport extends visitor_1.JavaScriptVisitor {
         });
     }
     async visitIdentifier(identifier, p) {
-        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);
-        return !this.renaming && type === identifier.type && fieldType === identifier.fieldType
-            ? identifier
-            : Object.assign(Object.assign({}, identifier), { simpleName: this.boundName, type, fieldType });
-    }
-    async visitMethodInvocation(method, p) {
-        const m = await super.visitMethodInvocation(method, p);
-        if (!this.referencesMovedBinding(m.name)) {
-            return m;
-        }
-        const methodType = await this.movedTypes.visit(m.methodType, undefined);
-        return methodType === m.methodType ? m : Object.assign(Object.assign({}, m), { methodType });
-    }
-    async visitNewClass(newClass, p) {
-        const nc = await super.visitNewClass(newClass, p);
-        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);
-        const constructorType = await this.movedTypes.visit(nc.constructorType, undefined);
-        return type === nc.type && methodType === nc.methodType && constructorType === nc.constructorType
-            ? nc
-            : Object.assign(Object.assign({}, nc), { type, methodType, constructorType });
-    }
-    async visitFunctionCall(functionCall, p) {
-        var _a;
-        const fc = await super.visitFunctionCall(functionCall, p);
-        if (!this.referencesMovedBinding((_a = fc.function) === null || _a === void 0 ? void 0 : _a.element)) {
-            return fc;
-        }
-        const methodType = await this.movedTypes.visit(fc.methodType, undefined);
-        return methodType === fc.methodType ? fc : Object.assign(Object.assign({}, fc), { methodType });
+        const renamed = this.renaming && this.referencesBinding(identifier);
+        const visited = await super.visitIdentifier(identifier, p);
+        return renamed ? Object.assign(Object.assign({}, visited), { simpleName: this.boundName }) : 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.
-     */
-    referencesMovedBinding(callee) {
-        return (callee === null || callee === void 0 ? void 0 : callee.kind) === java_1.J.Kind.Identifier && this.references.has(callee.id);
+    /** Any type in the file can name what moved, whether or not it references the binding. */
+    async visitType(javaType, p) {
+        return this.movedTypes.visit(javaType, undefined);
     }
     /**
      * A decorator and the other type-name positions reach the tree through this hook, which the
@@ -1841,65 +1947,100 @@ class RebindImport extends visitor_1.JavaScriptVisitor {
         }
         const specifier = exportSpecifier.specifier;
         if (specifier.kind === java_1.J.Kind.Identifier && specifier.simpleName === this.localName) {
-            return Object.assign(Object.assign({}, exportSpecifier), { specifier: aliasing(specifier, this.boundName) });
+            const retyped = await this.retyped(specifier);
+            const alias = aliasing(retyped, this.boundName);
+            // The property name is the reference here, so it carries the binding's attribution.
+            const reference = Object.assign(Object.assign({}, alias.propertyName.element), { type: retyped.type, fieldType: retyped.fieldType });
+            return Object.assign(Object.assign({}, exportSpecifier), { specifier: Object.assign(Object.assign({}, alias), { propertyName: Object.assign(Object.assign({}, alias.propertyName), { element: reference }) }) });
         }
         if (specifier.kind === tree_1.JS.Kind.Alias) {
             const alias = specifier;
             const propertyName = alias.propertyName.element;
             return propertyName.kind === java_1.J.Kind.Identifier && propertyName.simpleName === this.localName
-                ? Object.assign(Object.assign({}, exportSpecifier), { specifier: Object.assign(Object.assign({}, alias), { propertyName: Object.assign(Object.assign({}, alias.propertyName), { element: Object.assign(Object.assign({}, propertyName), { simpleName: this.boundName }) }) }) })
+                ? Object.assign(Object.assign({}, exportSpecifier), { specifier: Object.assign(Object.assign({}, alias), { propertyName: Object.assign(Object.assign({}, alias.propertyName), { element: Object.assign(Object.assign({}, await this.retyped(propertyName)), { simpleName: this.boundName }) }) }) })
                 : exportSpecifier;
         }
         return super.visitExportSpecifier(exportSpecifier, p);
     }
+    /** `identifier` attributed to what moved, for a rewrite that does not visit it again. */
+    async retyped(identifier) {
+        return Object.assign(Object.assign({}, 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.
      */
     referencesBinding(identifier) {
+        return identifier.simpleName === this.localName && this.readsModuleBinding(identifier);
+    }
+    readsModuleBinding(identifier) {
         var _a;
-        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 === null || v === void 0 ? void 0 : v.kind) === tree_1.JS.Kind.Import) &&
-            (0, scope_1.isValueReference)(this.cursor, identifier) &&
-            ((_a = (0, scope_1.scopeOf)(this.cursor).declaringScope(this.localName)) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.CompilationUnit;
+        return ((_a = (0, scope_1.resolve)(this.cursor, identifier)) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.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}`.
+     */
     async visitPropertyAssignment(propertyAssignment, p) {
-        var _a;
         const name = propertyAssignment.name.element;
-        if (this.renaming && propertyAssignment.initializer === undefined &&
+        if (this.renaming && propertyAssignment.assigmentToken === tree_1.JS.PropertyAssignment.Token.Equals &&
             name.kind === java_1.J.Kind.Identifier && name.simpleName === this.localName &&
-            ((_a = (0, scope_1.scopeOf)(this.cursor).declaringScope(this.localName)) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.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.
-            return Object.assign(Object.assign({}, propertyAssignment), { name: Object.assign(Object.assign({}, propertyAssignment.name), { element: Object.assign(Object.assign({}, name), { type: undefined, fieldType: undefined }) }), assigmentToken: tree_1.JS.PropertyAssignment.Token.Colon, initializer: Object.assign(Object.assign({}, name), { prefix: java_1.singleSpace, simpleName: this.boundName }) });
+            this.readsModuleBinding(name)) {
+            const reference = Object.assign(Object.assign({}, await this.retyped(name)), { 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 Object.assign(Object.assign({}, propertyAssignment), { name: Object.assign(Object.assign({}, propertyAssignment.name), { element: Object.assign(Object.assign({}, name), { id: (0, uuid_1.randomId)(), type: undefined, fieldType: undefined }), after: java_1.emptySpace }), assigmentToken: tree_1.JS.PropertyAssignment.Token.Colon, initializer: fallback === undefined ? Object.assign(Object.assign({}, reference), { prefix: java_1.singleSpace }) : {
+                    id: (0, uuid_1.randomId)(),
+                    kind: java_1.J.Kind.Assignment,
+                    prefix: java_1.singleSpace,
+                    markers: markers_1.emptyMarkers,
+                    variable: Object.assign(Object.assign({}, reference), { prefix: java_1.emptySpace }),
+                    assignment: {
+                        kind: java_1.J.Kind.LeftPadded,
+                        before: propertyAssignment.name.after,
+                        element: fallback,
+                        markers: markers_1.emptyMarkers
+                    },
+                    type: reference.type
+                } });
         }
         return super.visitPropertyAssignment(propertyAssignment, p);
     }
 }
 exports.RebindImport = RebindImport;
-/**
- * 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 type_visitor_1.TypeVisitor {
-    constructor(from, to) {
+    /**
+     * `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(from, to, shared) {
+        var _a;
         super();
+        this.from = from;
+        this.to = to;
         this.onPath = new Set();
         this.answered = new Map();
-        // 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.modules = new Map();
         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)}.${(_a = this.toMember) !== null && _a !== void 0 ? _a : 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.
      */
     async visit(type, p) {
         if (type === undefined || this.onPath.has(type)) {
@@ -1918,35 +2059,54 @@ class MovedTypes extends type_visitor_1.TypeVisitor {
             this.onPath.delete(type);
         }
     }
+    /** A class's members are left out, which keeps the walk to a type's signature, as in Java's `ChangeType`. */
     async visitClass(aClass, p) {
-        const visited = await super.visitClass(aClass, p);
-        const moved = this.renamed.get(visited.fullyQualifiedName);
-        return moved === undefined || moved === visited.fullyQualifiedName
-            ? visited
-            : Object.assign(Object.assign({}, visited), { fullyQualifiedName: moved });
+        const visited = (0, util_1.updateIfChanged)(aClass, {
+            supertype: await this.visit(aClass.supertype, p),
+            owningClass: await this.visit(aClass.owningClass, p),
+            interfaces: aClass.interfaces && await (0, util_1.mapAsync)(aClass.interfaces, i => this.visit(i, p)),
+            typeParameters: aClass.typeParameters && await (0, util_1.mapAsync)(aClass.typeParameters, t => this.visit(t, p))
+        });
+        const moved = this.classes.get(visited.fullyQualifiedName);
+        return moved === undefined ? visited : Object.assign(Object.assign({}, visited), { fullyQualifiedName: moved });
     }
     async visitMethod(method, p) {
+        var _a;
         const visited = await super.visitMethod(method, p);
-        return this.declaresMovedMember(visited.name, visited.declaringType)
-            ? Object.assign(Object.assign({}, visited), { name: this.toMember })
-            : visited;
+        if (!this.isMovedMember(method.name, method.declaringType)) {
+            return visited;
+        }
+        const declaringType = this.movedModule(method.declaringType);
+        return Object.assign(Object.assign({}, visited), { declaringType, name: (_a = this.toMember) !== null && _a !== void 0 ? _a : visited.name });
     }
     async visitVariable(variable, p) {
+        var _a;
         const visited = await super.visitVariable(variable, p);
-        return this.declaresMovedMember(visited.name, visited.owner)
-            ? Object.assign(Object.assign({}, visited), { name: this.toMember })
-            : visited;
+        if (!this.isMovedMember(variable.name, variable.owner)) {
+            return visited;
+        }
+        return Object.assign(Object.assign({}, visited), { owner: this.movedModule(variable.owner), name: (_a = this.toMember) !== null && _a !== void 0 ? _a : visited.name });
     }
     /**
-     * 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.
      */
-    declaresMovedMember(name, owner) {
-        return this.toMember !== undefined && name === this.fromMember && this.toMember !== this.fromMember &&
-            owner !== undefined && java_1.Type.isFullyQualified(owner) &&
-            java_1.Type.FullyQualified.getFullyQualifiedName(owner) === this.toModule;
+    isMovedMember(name, owner) {
+        return this.fromMember !== undefined && name === this.fromMember && owner !== undefined &&
+            java_1.Type.isFullyQualified(owner) && java_1.Type.FullyQualified.getFullyQualifiedName(owner) === this.from.module;
     }
+    movedModule(owner) {
+        let moved = this.modules.get(owner);
+        if (moved === undefined) {
+            moved = Object.assign(Object.assign({}, owner), { fullyQualifiedName: this.to.module });
+            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) {
+    return module.startsWith('.') || module.startsWith('/') ? module : (0, package_name_1.packageNameOf)(module);
 }
 /** A member's qualified name, or the module's own where no member is named. */
 function qualifiedName(binding) {