@openrewrite/rewrite 8.91.2 → 8.91.3

package/dist/javascript/add-import.js

@@ -4,7 +4,12 @@ exports.RebindImport = exports.AddImport = exports.ImportStyle = void 0;
 exports.bindImport = bindImport;
 exports.memberName = memberName;
 exports.moduleScopeBindings = moduleScopeBindings;
+exports.hasEsmSyntax = hasEsmSyntax;
+exports.isCommonJs = isCommonJs;
+exports.requiredModuleOfDeclaration = requiredModuleOfDeclaration;
 exports.requiredModuleOf = requiredModuleOf;
+exports.takenNames = takenNames;
+exports.nameTaken = nameTaken;
 exports.moduleNameOf = moduleNameOf;
 exports.existingImportBinding = existingImportBinding;
 const visitor_1 = require("./visitor");
@@ -15,6 +20,9 @@ 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;
 (function (ImportStyle) {
     ImportStyle[ImportStyle["ES6Named"] = 0] = "ES6Named";
@@ -75,15 +83,13 @@ function bindImport(visitor, options, refuseCreate) {
         visitor.afterVisit.push(new AddImport(options, derived));
         return derived;
     }
-    // An import already serving this request answers it; queuing one would, on the next cycle,
-    // derive a suffixed name from the binding this call just added. A caller that named a preference
-    // takes whatever comes back; one that did not assumes the name it derived, so a binding under
-    // any other name would leave the references it emits unbound.
+    // An import already serving this request answers it, under whatever name the file gave it —
+    // only a pinned alias, returned above, asks for a binding of its own. Queuing a second import
+    // would, on the next cycle, derive a suffixed name from the binding this call just added.
+    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 &&
-            (options.preferredName !== undefined || anyNameAnswers(options) ||
-                binding.name === derived)) {
+            binding.typeOnly === typeOnly && scope.declaringScope(binding.name) === cu) {
             return binding.name;
         }
     }
@@ -168,6 +174,62 @@ function moduleScopeBindings(cu) {
     }
     return bindings;
 }
+/** Whether a top-level statement already marks the file as a module: an import or any export form. */
+function hasEsmSyntax(cu) {
+    return cu.statements.some(stmt => {
+        var _a;
+        const element = stmt.element;
+        // `export {a, b}`, `export * from` and `export default` are their own statement kinds;
+        // `export class`/`function`/`const` instead carry `export` as a modifier on the
+        // declaration itself, the same way TypeScript's own AST models it.
+        const modifiers = element === null || element === void 0 ? void 0 : element.modifiers;
+        return (element === null || element === void 0 ? void 0 : element.kind) === tree_1.JS.Kind.Import ||
+            (element === null || element === void 0 ? void 0 : element.kind) === tree_1.JS.Kind.ExportDeclaration ||
+            (element === null || element === void 0 ? void 0 : element.kind) === tree_1.JS.Kind.ExportAssignment ||
+            ((_a = modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(m => m.keyword === "export")) !== null && _a !== void 0 ? _a : false);
+    }) || hasTopLevelAwait(cu);
+}
+/**
+ * Whether a statement holds an `await` outside any function of its own — legal only at module
+ * top level, unlike an `await` inside an `async function`, which says nothing about the file.
+ */
+function hasTopLevelAwait(cu) {
+    let found = false;
+    (0, scope_1.walk)(cu.statements, node => {
+        if (found) {
+            return false;
+        }
+        if (node.kind === tree_1.JS.Kind.Await) {
+            found = true;
+            return false;
+        }
+        return node.kind !== java_1.J.Kind.MethodDeclaration && node.kind !== java_1.J.Kind.Lambda;
+    });
+    return found;
+}
+/** Whether the file binds its modules with `require`, which decides whether a create is possible. */
+function isCommonJs(cu) {
+    if (cu.sourcePath.endsWith(".cjs") || cu.sourcePath.endsWith(".cts")) {
+        return true;
+    }
+    // Node treats these as ES modules regardless of what they contain, the same way
+    // `determineImportStyle` reads them as ES6-preferring; `.js`/`.ts`/`.tsx` stay ambiguous and
+    // fall through to the statements below.
+    if (cu.sourcePath.endsWith(".mjs") || cu.sourcePath.endsWith(".mts")) {
+        return false;
+    }
+    if (hasEsmSyntax(cu)) {
+        return false;
+    }
+    return cu.statements.some(stmt => (0, scope_1.declarationsOf)(stmt.element).some(d => requiredModuleOfDeclaration(d) !== undefined));
+}
+/** The module a `const X = require('m')` declaration names, for the one variable it declares. */
+function requiredModuleOfDeclaration(declaration) {
+    var _a, _b;
+    return declaration.variables.length === 1
+        ? requiredModule((_b = (_a = declaration.variables[0].element) === null || _a === void 0 ? void 0 : _a.initializer) === null || _b === void 0 ? void 0 : _b.element)
+        : undefined;
+}
 /** The module a `require('...')` initializer names, `undefined` for an initializer that is anything else. */
 function requiredModule(initializer) {
     return (initializer === null || initializer === void 0 ? void 0 : initializer.kind) === java_1.J.Kind.MethodInvocation
@@ -257,12 +319,12 @@ function importBindings(jsImport) {
     return bindings;
 }
 /**
- * Names in scope, plus those pending `AddImport`s on the `afterVisit` queue have claimed. A queued
+ * `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.
  */
-function takenNames(inScope, visitor) {
-    const taken = new Set(inScope);
+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);
@@ -270,6 +332,11 @@ function takenNames(inScope, visitor) {
     }
     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);
+}
 /**
  * The parser lifts surrogate pairs out of `valueSource` into `unicodeEscapes` and, when it does,
  * sets `value` to the quoted source (`parser.ts` `mapLiteral`), so neither field alone is the
@@ -371,8 +438,8 @@ async function detectQuote(cu) {
     if (specifierQuote) {
         return specifierQuote;
     }
-    const prettier = (0, style_1.getStyle)(style_1.StyleKind.PrettierStyle, cu);
-    if ((prettier === null || prettier === void 0 ? void 0 : prettier.kind) === style_1.StyleKind.PrettierStyle && !prettier.ignored) {
+    const prettier = (0, prettier_format_1.getPrettierStyle)(cu);
+    if (prettier && !prettier.ignored) {
         const singleQuote = prettier.config.singleQuote;
         if (typeof singleQuote === 'boolean') {
             return singleQuote ? "'" : '"';
@@ -380,6 +447,32 @@ async function detectQuote(cu) {
     }
     return double > single ? '"' : "'";
 }
+/**
+ * Lays out the import statement `AddImport` wrote, so that the file's own style — a Prettier
+ * configuration's brace spacing and print width, say — reaches it.
+ */
+async function formatImport(cu, id, p) {
+    return await new class extends visitor_1.JavaScriptVisitor {
+        async visitImportDeclaration(jsImport, p) {
+            return jsImport.id === id ? await (0, format_1.autoFormat)(jsImport, p, undefined, this.cursor.parent) : jsImport;
+        }
+    }().visit(cu, p);
+}
+/**
+ * As {@link formatImport}, for an import that gained specifiers. Short of a Prettier configuration
+ * deciding the whole line, the statement's own text says more about its spacing than a
+ * repository-wide style does, and the merge reads it directly.
+ */
+async function formatMergedImport(cu, id, p) {
+    var _a;
+    return ((_a = (0, prettier_format_1.getPrettierStyle)(cu)) === null || _a === void 0 ? void 0 : _a.ignored) === false ? formatImport(cu, id, p) : cu;
+}
+/**
+ * Adds the import {@link AddImportOptions} describes, under the name derived there. An import
+ * already in the file answers where it binds that same name, or where the request expressed no
+ * preference at all. Reuse under some other name belongs to {@link bindImport}, whose caller
+ * learns which name came back; a recipe driving this visitor is stuck with the one it derived.
+ */
 class AddImport extends visitor_1.JavaScriptVisitor {
     constructor(options, bindingName) {
         var _a, _b, _c;
@@ -581,17 +674,18 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 return mergedCu;
             }
         }
-        // Add the import using the appropriate style
-        if (importStyle === ImportStyle.CommonJS) {
-            // TODO: Implement CommonJS require creation
-            // For now, fall back to ES6 imports
-            // return this.addCommonJSRequire(compilationUnit, p);
+        // TODO: create a `require` here. Until then the request goes unserved, since `import` would
+        // make a file that binds its modules with `require` an ES module and change how everything
+        // in it loads — `maybeBind` refuses it for the same reason. An explicit ES6 `style`
+        // overrides, which is how a caller converting the file to ESM asks for one.
+        if (importStyle === ImportStyle.CommonJS && isCommonJs(compilationUnit)) {
+            return compilationUnit;
         }
         // Add ES6 import (handles ES6Named, ES6Namespace, ES6Default)
-        return this.produceJavaScript(compilationUnit, p, async (draft) => {
-            // Find the position to insert the import
-            const insertionIndex = this.findImportInsertionIndex(compilationUnit);
-            const newImport = await this.createImportStatement(compilationUnit, insertionIndex, p);
+        // Find the position to insert the import
+        const insertionIndex = this.findImportInsertionIndex(compilationUnit);
+        const newImport = await this.createImportStatement(compilationUnit, insertionIndex, p);
+        const withImport = await this.produceJavaScript(compilationUnit, p, async (draft) => {
             // Insert the import at the appropriate position
             // Create semicolon marker for the import statement
             const semicolonMarkers = (0, markers_1.markers)({
@@ -638,6 +732,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                 }
             }
         });
+        return formatImport(withImport, newImport.id, p);
     }
     /**
      * Try to merge the new member into an existing import from the same module
@@ -673,7 +768,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                         continue;
                     }
                     // We found a matching import with named bindings - merge into it
-                    return this.produceJavaScript(compilationUnit, p, async (draft) => {
+                    return formatMergedImport(await this.produceJavaScript(compilationUnit, p, async (draft) => {
                         var _a, _b, _c;
                         const namedImports = importClause.namedBindings;
                         const existingElements = namedImports.elements.elements;
@@ -733,12 +828,12 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                         });
                         // Replace the statement in the compilation unit
                         draft.statements = compilationUnit.statements.map((s, idx) => idx === i ? Object.assign(Object.assign({}, s), { element: updatedImport }) : s);
-                    });
+                    }), jsImport.id, 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) {
-                    return this.produceJavaScript(compilationUnit, p, async (draft) => {
+                    return formatMergedImport(await this.produceJavaScript(compilationUnit, p, async (draft) => {
                         const newSpecifier = this.createImportSpecifier();
                         // Get the spaces style for brace spacing
                         const spacesStyle = (0, style_1.getStyle)(style_1.StyleKind.SpacesStyle, compilationUnit);
@@ -774,7 +869,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
                         });
                         // Replace the statement in the compilation unit
                         draft.statements = compilationUnit.statements.map((s, idx) => idx === i ? Object.assign(Object.assign({}, s), { element: updatedImport }) : s);
-                    });
+                    }), jsImport.id, p);
                 }
             }
         }
@@ -1076,10 +1171,8 @@ class AddImport extends visitor_1.JavaScriptVisitor {
         var _a;
         // Determine the appropriate prefix (spacing before the import)
         const prefix = this.determineImportPrefix(compilationUnit, insertionIndex);
-        // Create the module specifier
-        // For side-effect imports, use emptySpace since space comes from LeftPadded.before
-        // For regular imports with import clause, use emptySpace since space comes from LeftPadded.before
-        // However, the printer expects the space after 'from' in the literal's prefix
+        // Whitespace throughout follows the parser's placement, so that formatting the result is a
+        // no-op where the file's style already agrees with it.
         // Note: value is the unquoted module name; valueSource and unicodeEscapes are its printed form
         let valueSource = this.moduleValueSource;
         if (valueSource === undefined) {
@@ -1089,7 +1182,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
         const moduleSpecifier = {
             id: (0, uuid_1.randomId)(),
             kind: java_1.J.Kind.Literal,
-            prefix: this.sideEffectOnly ? java_1.emptySpace : java_1.singleSpace,
+            prefix: java_1.singleSpace,
             markers: markers_1.emptyMarkers,
             value: this.module,
             valueSource,
@@ -1126,7 +1219,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             const namespaceBinding = {
                 id: (0, uuid_1.randomId)(),
                 kind: tree_1.JS.Kind.Alias,
-                prefix: java_1.singleSpace,
+                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
                 markers: markers_1.emptyMarkers,
                 propertyName: (0, java_1.rightPadded)(propertyName, java_1.singleSpace),
                 alias: aliasIdentifier
@@ -1134,7 +1227,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             importClause = {
                 id: (0, uuid_1.randomId)(),
                 kind: tree_1.JS.Kind.ImportClause,
-                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
+                prefix: java_1.singleSpace,
                 markers: markers_1.emptyMarkers,
                 typeOnly: this.typeOnly,
                 name: undefined,
@@ -1147,7 +1240,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             const defaultName = {
                 id: (0, uuid_1.randomId)(),
                 kind: java_1.J.Kind.Identifier,
-                prefix: java_1.singleSpace,
+                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
                 markers: markers_1.emptyMarkers,
                 annotations: [],
                 simpleName: this.bindingName,
@@ -1157,10 +1250,10 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             importClause = {
                 id: (0, uuid_1.randomId)(),
                 kind: tree_1.JS.Kind.ImportClause,
-                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
+                prefix: java_1.singleSpace,
                 markers: markers_1.emptyMarkers,
                 typeOnly: this.typeOnly,
-                name: (0, java_1.rightPadded)(defaultName, java_1.emptySpace),
+                name: (0, java_1.rightPadded)(defaultName, java_1.singleSpace),
                 namedBindings: undefined
             };
         }
@@ -1176,11 +1269,11 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             const namedImports = {
                 id: (0, uuid_1.randomId)(),
                 kind: tree_1.JS.Kind.NamedImports,
-                prefix: java_1.singleSpace,
+                prefix: java_1.emptySpace,
                 markers: markers_1.emptyMarkers,
                 elements: {
                     kind: java_1.J.Kind.Container,
-                    before: java_1.emptySpace,
+                    before: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
                     elements: [(0, java_1.rightPadded)(importSpecWithSpacing, braceSpace)],
                     markers: markers_1.emptyMarkers
                 }
@@ -1188,7 +1281,7 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             importClause = {
                 id: (0, uuid_1.randomId)(),
                 kind: tree_1.JS.Kind.ImportClause,
-                prefix: this.typeOnly ? java_1.singleSpace : java_1.emptySpace,
+                prefix: java_1.singleSpace,
                 markers: markers_1.emptyMarkers,
                 typeOnly: this.typeOnly,
                 name: undefined,
@@ -1204,7 +1297,9 @@ class AddImport extends visitor_1.JavaScriptVisitor {
             importClause,
             moduleSpecifier: {
                 kind: java_1.J.Kind.LeftPadded,
-                before: java_1.singleSpace,
+                // Bindings end at `}`, so the space before `from` sits here; a default import's name
+                // and a side-effect import's literal carry their own
+                before: (importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) ? java_1.singleSpace : java_1.emptySpace,
                 element: moduleSpecifier,
                 markers: markers_1.emptyMarkers
             },
@@ -1426,15 +1521,20 @@ function existingImportBinding(cu, module, member) {
         }
         const localName = importBinds(element, module, member);
         if (localName !== undefined) {
-            return { localName, onlyMemberOfStatement: isOnlyMember(element) };
+            return {
+                localName,
+                onlyMemberOfStatement: isOnlyMember(element),
+                aliased: localName !== memberName(member)
+            };
         }
     }
     return undefined;
 }
 /**
- * Binds `member` under the name `local` already carries, so the file's references to it still
- * resolve. `local` itself becomes the alias, keeping the type attribution it holds, and the alias
- * takes its prefix: that whitespace separates the specifier from a `type` keyword before it.
+ * The `member as local` specifier, for an import binding `member` under `local` or an export
+ * publishing `local`'s binding under that name. `local` itself becomes the alias, keeping the type
+ * attribution it holds, and the alias takes its prefix: that whitespace separates the specifier
+ * from a `type` keyword before it.
  */
 function aliasing(local, member) {
     const propertyName = {
@@ -1514,22 +1614,29 @@ function removeBinding(jsImport, member) {
     return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: updatedNamedImports }) });
 }
 /**
- * Moves the binding `from` names to `to`, keeping the local name it already had. 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,
- * aliased to the preserved name.
+ * 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.
  *
  * 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.
  */
 class RebindImport extends visitor_1.JavaScriptVisitor {
-    constructor(from, to, localName) {
+    constructor(from, to, localName, boundName) {
         super();
         this.from = from;
         this.to = to;
         this.localName = localName;
+        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);
@@ -1537,7 +1644,7 @@ class RebindImport extends visitor_1.JavaScriptVisitor {
             bindImport(this, {
                 module: this.to.module,
                 member: this.to.member,
-                alias: this.localName,
+                alias: this.boundName,
                 typeOnly: this.typeOnly,
                 onlyIfReferenced: false
             });
@@ -1548,7 +1655,9 @@ class RebindImport extends visitor_1.JavaScriptVisitor {
         var _a, _b;
         const imp = await super.visitImportDeclaration(jsImport, p);
         const key = memberName(this.from.member);
-        if (importBinds(imp, this.from.module, this.from.member) === undefined) {
+        // 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) {
             return imp;
         }
         // A moved named specifier's own inline `type` marks it type-only even where the clause
@@ -1566,31 +1675,249 @@ class RebindImport extends visitor_1.JavaScriptVisitor {
             const originalSource = literal.valueSource || `"${this.from.module}"`;
             const quoteChar = originalSource.startsWith("'") ? "'" : '"';
             literal.valueSource = `${quoteChar}${this.to.module}${quoteChar}`;
-            // A named specifier's local name has to stay put in the source, since it is what the
-            // rest of the file already reads; default and namespace imports carry that name on
-            // the clause itself, which needs no edit for a module-only move.
-            const toKey = memberName(this.to.member);
-            if (key !== undefined && key !== '*' && toKey !== undefined && toKey !== key) {
-                const importClause = draft.importClause;
-                if (((_a = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.NamedImports) {
-                    const namedImports = importClause.namedBindings;
-                    for (const elem of namedImports.elements.elements) {
-                        const specifier = elem.element;
-                        if (specifier.specifier.kind === java_1.J.Kind.Identifier && specifier.specifier.simpleName === key) {
-                            specifier.specifier = aliasing(specifier.specifier, toKey);
-                        }
-                        else if (specifier.specifier.kind === tree_1.JS.Kind.Alias) {
-                            const aliasNode = specifier.specifier;
-                            const propertyName = aliasNode.propertyName.element;
-                            if (propertyName.kind === java_1.J.Kind.Identifier && propertyName.simpleName === key) {
-                                propertyName.simpleName = toKey;
-                            }
-                        }
-                    }
+            // A default or namespace import carries its local name on the clause itself; a named
+            // one states the member alongside it, in the specifier.
+            if (key === undefined || key === '*') {
+                if (this.boundName !== this.localName) {
+                    renameClauseBinding(draft.importClause, key, this.boundName);
                 }
+                return;
             }
+            rewriteNamedSpecifier(draft.importClause, key, (_a = memberName(this.to.member)) !== null && _a !== void 0 ? _a : key, this.boundName);
         });
     }
+    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 });
+    }
+    /**
+     * 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);
+    }
+    /**
+     * A decorator and the other type-name positions reach the tree through this hook, which the
+     * base visitor holds closed; a reference in one of them is a reference like any other.
+     */
+    async visitTypeName(nameTree, p) {
+        return await this.visit(nameTree, p);
+    }
+    /**
+     * An export specifier's own name is the module's public surface, which its consumers read and
+     * the rename leaves alone. See CLAUDE.md: Which name a rebind binds.
+     */
+    async visitExportSpecifier(exportSpecifier, p) {
+        if (!this.renaming) {
+            return super.visitExportSpecifier(exportSpecifier, p);
+        }
+        // `export {a} from "m"` names `m`'s member rather than anything this file binds.
+        const from = this.cursor.firstEnclosing((v) => (v === null || v === void 0 ? void 0 : v.kind) === tree_1.JS.Kind.ExportDeclaration);
+        if ((from === null || from === void 0 ? void 0 : from.moduleSpecifier) !== undefined) {
+            return exportSpecifier;
+        }
+        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) });
+        }
+        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 }) }) }) })
+                : exportSpecifier;
+        }
+        return super.visitExportSpecifier(exportSpecifier, p);
+    }
+    /**
+     * 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.
+     */
+    referencesBinding(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;
+    }
+    /** A shorthand property's name slot is also the reference to the binding. */
+    async visitPropertyAssignment(propertyAssignment, p) {
+        var _a;
+        const name = propertyAssignment.name.element;
+        if (this.renaming && propertyAssignment.initializer === undefined &&
+            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 }) });
+        }
+        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.
+ */
+class MovedTypes extends type_visitor_1.TypeVisitor {
+    constructor(from, to) {
+        super();
+        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.fromMember = declaredMember(from);
+        this.toMember = declaredMember(to);
+        this.toModule = to.module;
+    }
+    /**
+     * 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
+     * reference to a binding shares one type, so a completed walk is remembered for the next.
+     */
+    async visit(type, p) {
+        if (type === undefined || this.onPath.has(type)) {
+            return type;
+        }
+        if (this.answered.has(type)) {
+            return this.answered.get(type);
+        }
+        this.onPath.add(type);
+        try {
+            const answer = await super.visit(type, p);
+            // Only the type a walk entered at is remembered: one reached inside it may have met
+            // a back edge, which answers with the type itself and so stands for the path it was on.
+            if (this.onPath.size === 1) {
+                this.answered.set(type, answer);
+            }
+            return answer;
+        }
+        finally {
+            this.onPath.delete(type);
+        }
+    }
+    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 });
+    }
+    async visitMethod(method, p) {
+        const visited = await super.visitMethod(method, p);
+        return this.declaresMovedMember(visited.name, visited.declaringType)
+            ? Object.assign(Object.assign({}, visited), { name: this.toMember })
+            : visited;
+    }
+    async visitVariable(variable, p) {
+        const visited = await super.visitVariable(variable, p);
+        return this.declaresMovedMember(visited.name, visited.owner)
+            ? Object.assign(Object.assign({}, visited), { name: this.toMember })
+            : visited;
+    }
+    /**
+     * 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.
+     */
+    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;
+    }
+}
+/** A member's qualified name, or the module's own where no member is named. */
+function qualifiedName(binding) {
+    const key = memberName(binding.member);
+    return key === undefined || key === '*' ? binding.module : `${binding.module}.${key}`;
+}
+/** The member the module declares, where the binding names one: a whole module declares none. */
+function declaredMember(binding) {
+    const key = memberName(binding.member);
+    return key === undefined || key === '*' ? undefined : key;
+}
+/** Renames the identifier a default (`key` undefined) or namespace clause binds its module under. */
+function renameClauseBinding(importClause, key, boundName) {
+    var _a, _b;
+    const bound = key === undefined
+        ? (_a = importClause === null || importClause === void 0 ? void 0 : importClause.name) === null || _a === void 0 ? void 0 : _a.element
+        : (_b = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _b === void 0 ? void 0 : _b.alias;
+    if ((bound === null || bound === void 0 ? void 0 : bound.kind) === java_1.J.Kind.Identifier) {
+        bound.simpleName = boundName;
+    }
+}
+/**
+ * Rewrites the specifier importing `key` to import `member` under `boundName` — a bare `{member}`
+ * where the two agree, since an alias saying the same thing is noise the source never had.
+ */
+function rewriteNamedSpecifier(importClause, key, member, boundName) {
+    var _a, _b;
+    if (((_a = importClause === null || importClause === void 0 ? void 0 : importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) !== tree_1.JS.Kind.NamedImports) {
+        return;
+    }
+    for (const elem of importClause.namedBindings.elements.elements) {
+        const specifier = elem.element;
+        const node = specifier.specifier;
+        if (!namedSpecifierImports(node, key)) {
+            continue;
+        }
+        const alias = node.kind === tree_1.JS.Kind.Alias ? node : undefined;
+        const local = ((_b = alias === null || alias === void 0 ? void 0 : alias.alias) !== null && _b !== void 0 ? _b : node);
+        if (local.kind !== java_1.J.Kind.Identifier) {
+            continue;
+        }
+        if (boundName === member) {
+            // An alias node holds the specifier's leading whitespace, so the bare identifier
+            // standing in for it takes that prefix.
+            specifier.specifier = Object.assign(Object.assign({}, local), { prefix: (alias !== null && alias !== void 0 ? alias : local).prefix, simpleName: member });
+        }
+        else if (alias) {
+            alias.propertyName.element.simpleName = member;
+            local.simpleName = boundName;
+        }
+        else {
+            specifier.specifier = aliasing(Object.assign(Object.assign({}, local), { simpleName: boundName }), member);
+        }
+    }
+}
 //# sourceMappingURL=add-import.js.map