@openrewrite/rewrite 8.91.1 → 8.91.2

package/dist/javascript/add-import.js

@@ -1,13 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddImport = exports.ImportStyle = void 0;
-exports.maybeAddImport = maybeAddImport;
+exports.RebindImport = exports.AddImport = exports.ImportStyle = void 0;
+exports.bindImport = bindImport;
+exports.memberName = memberName;
+exports.moduleScopeBindings = moduleScopeBindings;
+exports.requiredModuleOf = requiredModuleOf;
+exports.moduleNameOf = moduleNameOf;
+exports.existingImportBinding = existingImportBinding;
 const visitor_1 = require("./visitor");
 const java_1 = require("../java");
 const tree_1 = require("./tree");
 const uuid_1 = require("../uuid");
 const markers_1 = require("../markers");
 const style_1 = require("./style");
+const scope_1 = require("./scope");
+const mutative_1 = require("mutative");
 var ImportStyle;
 (function (ImportStyle) {
     ImportStyle[ImportStyle["ES6Named"] = 0] = "ES6Named";
@@ -15,7 +22,13 @@ var ImportStyle;
     ImportStyle[ImportStyle["ES6Default"] = 2] = "ES6Default";
     ImportStyle[ImportStyle["CommonJS"] = 3] = "CommonJS"; // const x = require('module')
 })(ImportStyle || (exports.ImportStyle = ImportStyle = {}));
-function maybeAddImport(visitor, options) {
+/**
+ * Ensures an import for `options.module` exists, queuing an `AddImport` edit where none already
+ * serves the request. `maybeBind`'s ESM/CommonJS lane is this function; its own JSDoc carries the
+ * return-value contract. `refuseCreate` answers `undefined` instead of queuing a new import,
+ * without affecting whether an existing binding answers the request first.
+ */
+function bindImport(visitor, options, refuseCreate) {
     var _a, _b;
     validate(options);
     const module = moduleNameOf(options.module);
@@ -38,26 +51,35 @@ function maybeAddImport(visitor, options) {
         }
     }
     if (sideEffectOnly) {
+        if (refuseCreate) {
+            return undefined;
+        }
         visitor.afterVisit.push(new AddImport(options));
         return undefined;
     }
     // A pinned alias is the whole answer, so the file has no say and nothing below needs to read it.
     if (options.alias) {
+        if (refuseCreate) {
+            return undefined;
+        }
         visitor.afterVisit.push(new AddImport(options, options.alias));
         return options.alias;
     }
     const derived = derivedName(options);
-    const cu = compilationUnitOf(visitor);
+    const cursor = (0, scope_1.cursorOf)(visitor);
+    const cu = cursor && (0, scope_1.compilationUnitOf)(cursor);
     if (!cu) {
+        if (refuseCreate) {
+            return undefined;
+        }
         visitor.afterVisit.push(new AddImport(options, derived));
         return derived;
     }
-    const bindings = bindingsInScope(cu, cursorOf(visitor));
     // 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.
-    for (const binding of bindings) {
+    for (const binding of moduleScopeBindings(cu)) {
         if (binding.module === module && binding.member === memberName(options.member) &&
             binding.typeOnly === typeOnly &&
             (options.preferredName !== undefined || anyNameAnswers(options) ||
@@ -65,7 +87,14 @@ function maybeAddImport(visitor, options) {
             return binding.name;
         }
     }
-    const name = deconflict(derived, takenNames(bindings, visitor));
+    if (refuseCreate) {
+        return undefined;
+    }
+    // Only the module scope answers for a name, but any scope in the file occupies one. The queue
+    // gives every later request for this module the name chosen here, so it has to clear the scopes
+    // those references will sit in, which are not known yet.
+    const taken = takenNames((0, scope_1.namesDeclaredIn)(cu), visitor);
+    const name = (0, scope_1.deconflict)(derived, candidate => taken.has(candidate));
     visitor.afterVisit.push(new AddImport(options, name));
     return name;
 }
@@ -115,104 +144,26 @@ function derivedName(options) {
 function memberName(member) {
     return member === 'default' ? undefined : member;
 }
-function cursorOf(visitor) {
-    return visitor.cursor;
-}
-function compilationUnitOf(visitor) {
-    var _a;
-    // `cursor` is protected on `TreeVisitor`, and the `maybeAddImport`/`maybeRemoveImport`
-    // API is free functions, so reaching it takes a cast.
-    return (_a = cursorOf(visitor)) === null || _a === void 0 ? void 0 : _a.firstEnclosing((v) => (v === null || v === void 0 ? void 0 : v.kind) === tree_1.JS.Kind.CompilationUnit);
-}
-/** Every name in scope at `cursor`: what the file binds, and what each block enclosing it declares. */
-function bindingsInScope(cu, cursor) {
-    const bindings = statementBindings(cu.statements);
-    // A local shadows an import for the code the template lands in, so a name a block declares is
-    // taken there even though the module never answers for it.
-    for (let c = cursor; c && c.value !== cu; c = c.parent) {
-        for (const name of scopeNames(c.value)) {
-            bindings.push({ name });
-        }
-    }
-    return bindings;
-}
-/** The names a scope introduces directly: a block's declarations, or a function's parameters. */
-function scopeNames(scope) {
-    const node = scope;
-    if ((node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.Block) {
-        return statementBindings(node.statements).map(binding => binding.name);
-    }
-    if ((node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.MethodDeclaration) {
-        return node.parameters.elements
-            .flatMap(param => {
-            var _a;
-            return ((_a = param.element) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.VariableDeclarations
-                ? param.element.variables.flatMap(v => { var _a; return patternNames((_a = v.element) === null || _a === void 0 ? void 0 : _a.name); })
-                : patternNames(param.element);
-        })
-            .map(bound => bound.name);
-    }
-    if ((node === null || node === void 0 ? void 0 : node.kind) === java_1.J.Kind.Lambda) {
-        return node.parameters.parameters
-            .flatMap(param => {
-            var _a;
-            return ((_a = param.element) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.VariableDeclarations
-                ? param.element.variables.flatMap(v => { var _a; return patternNames((_a = v.element) === null || _a === void 0 ? void 0 : _a.name); })
-                : patternNames(param.element);
-        })
-            .map(bound => bound.name);
-    }
-    return [];
-}
-/** Imports are top-level statements and so is anything that can shadow one, so a flat scan sees every name. */
-function statementBindings(statements) {
-    var _a;
+/** What the file's imports and `require`s bind at module scope, and the module each name comes from. */
+function moduleScopeBindings(cu) {
     const bindings = [];
-    const declaredBy = (name) => {
-        for (const bound of patternNames(name)) {
-            bindings.push({ name: bound.name });
-        }
-    };
     const declaredByVariables = (varDecl) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         for (const variable of varDecl.variables) {
             const required = requiredModule((_b = (_a = variable.element) === null || _a === void 0 ? void 0 : _a.initializer) === null || _b === void 0 ? void 0 : _b.element);
             if (required !== undefined) {
                 bindings.push(...requireBindings((_c = variable.element) === null || _c === void 0 ? void 0 : _c.name, required));
             }
-            else {
-                declaredBy((_d = variable.element) === null || _d === void 0 ? void 0 : _d.name);
-            }
         }
     };
-    for (const stmt of statements) {
+    for (const stmt of cu.statements) {
         const statement = stmt.element;
-        switch (statement === null || statement === void 0 ? void 0 : statement.kind) {
-            case tree_1.JS.Kind.Import:
-                bindings.push(...importBindings(statement));
-                break;
-            case java_1.J.Kind.VariableDeclarations:
-                declaredByVariables(statement);
-                break;
-            case tree_1.JS.Kind.ScopedVariableDeclarations:
-                for (const variable of statement.variables) {
-                    if (((_a = variable.element) === null || _a === void 0 ? void 0 : _a.kind) === java_1.J.Kind.VariableDeclarations) {
-                        declaredByVariables(variable.element);
-                    }
-                }
-                break;
-            case java_1.J.Kind.MethodDeclaration:
-                declaredBy(statement.name);
-                break;
-            case java_1.J.Kind.ClassDeclaration:
-                declaredBy(statement.name);
-                break;
-            case tree_1.JS.Kind.NamespaceDeclaration:
-                declaredBy(statement.name.element);
-                break;
-            case tree_1.JS.Kind.TypeDeclaration:
-                declaredBy(statement.name.element);
-                break;
+        if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+            bindings.push(...importBindings(statement));
+            continue;
+        }
+        for (const declaration of (0, scope_1.declarationsOf)(statement)) {
+            declaredByVariables(declaration);
         }
     }
     return bindings;
@@ -243,59 +194,13 @@ function requiredModuleOf(methodInv) {
         ? moduleNameOf(argument)
         : undefined;
 }
-/**
- * Every name a binding pattern introduces. `member` is the property a name takes its value from,
- * and only a name bound directly by the pattern has one — anything deeper reads a property of a
- * property, so it occupies its name without binding a member of the module.
- */
-function patternNames(pattern) {
-    var _a, _b, _c;
-    if ((pattern === null || pattern === void 0 ? void 0 : pattern.kind) === java_1.J.Kind.Identifier) {
-        return [{ name: pattern.simpleName }];
-    }
-    // An array pattern binds by position, so its elements name no member of what they destructure.
-    if ((pattern === null || pattern === void 0 ? void 0 : pattern.kind) === tree_1.JS.Kind.ArrayBindingPattern) {
-        return pattern.elements.elements
-            .flatMap(elem => {
-            var _a;
-            return ((_a = elem.element) === null || _a === void 0 ? void 0 : _a.kind) === tree_1.JS.Kind.BindingElement
-                ? patternNames(elem.element.name)
-                : patternNames(elem.element);
-        })
-            .map(bound => ({ name: bound.name }));
-    }
-    if ((pattern === null || pattern === void 0 ? void 0 : pattern.kind) !== tree_1.JS.Kind.ObjectBindingPattern) {
-        return [];
-    }
-    const names = [];
-    for (const elem of pattern.bindings.elements) {
-        if (((_a = elem.element) === null || _a === void 0 ? void 0 : _a.kind) !== tree_1.JS.Kind.BindingElement) {
-            continue;
-        }
-        const bindingElem = elem.element;
-        if (((_b = bindingElem.name) === null || _b === void 0 ? void 0 : _b.kind) === java_1.J.Kind.Identifier) {
-            const name = bindingElem.name.simpleName;
-            const propertyName = (_c = bindingElem.propertyName) === null || _c === void 0 ? void 0 : _c.element;
-            names.push({
-                name,
-                member: (propertyName === null || propertyName === void 0 ? void 0 : propertyName.kind) === java_1.J.Kind.Identifier
-                    ? propertyName.simpleName
-                    : name
-            });
-        }
-        else {
-            names.push(...patternNames(bindingElem.name).map(bound => ({ name: bound.name })));
-        }
-    }
-    return names;
-}
 /** A `require` binds a module the way an import does, so the pool records it the same way. */
 function requireBindings(pattern, module) {
     // A whole-module require binds no member, exactly as a default import does.
     if ((pattern === null || pattern === void 0 ? void 0 : pattern.kind) === java_1.J.Kind.Identifier) {
         return [{ name: pattern.simpleName, module, member: undefined, typeOnly: false }];
     }
-    return patternNames(pattern).map(bound => bound.member === undefined
+    return (0, scope_1.bindingNames)(pattern).map(bound => bound.member === undefined
         ? { name: bound.name }
         : { name: bound.name, module, member: bound.member, typeOnly: false });
 }
@@ -352,32 +257,19 @@ function importBindings(jsImport) {
     return bindings;
 }
 /**
- * Names the file binds, 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 in scope, 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(bindings, visitor) {
-    const taken = new Set();
+function takenNames(inScope, visitor) {
+    const taken = new Set(inScope);
     for (const v of visitor.afterVisit || []) {
         if (v instanceof AddImport && v.bindingName) {
             taken.add(v.bindingName);
         }
     }
-    for (const binding of bindings) {
-        taken.add(binding.name);
-    }
     return taken;
 }
-function deconflict(derived, taken) {
-    if (!taken.has(derived)) {
-        return derived;
-    }
-    let suffix = 1;
-    while (taken.has(`${derived}_${suffix}`)) {
-        suffix++;
-    }
-    return `${derived}_${suffix}`;
-}
 /**
  * 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
@@ -1431,4 +1323,274 @@ class AddImport extends visitor_1.JavaScriptVisitor {
     }
 }
 exports.AddImport = AddImport;
+/**
+ * The local name `jsImport` binds `member` of `module` to, or `undefined` where it binds
+ * something else. `'default'` and an absent `member` both mean the default import, matching
+ * {@link memberName}.
+ */
+function importBinds(jsImport, module, member) {
+    var _a, _b;
+    const specifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+    if ((specifier === null || specifier === void 0 ? void 0 : specifier.kind) !== java_1.J.Kind.Literal || specifier.value !== module) {
+        return undefined;
+    }
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return undefined;
+    }
+    const key = memberName(member);
+    if (key === undefined) {
+        const nameElem = (_b = importClause.name) === null || _b === void 0 ? void 0 : _b.element;
+        return nameElem && (0, java_1.isIdentifier)(nameElem) ? nameElem.simpleName : undefined;
+    }
+    if (key === '*') {
+        const namedBindings = importClause.namedBindings;
+        return (namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.Alias && (0, java_1.isIdentifier)(namedBindings.alias)
+            ? namedBindings.alias.simpleName
+            : undefined;
+    }
+    const namedBindings = importClause.namedBindings;
+    if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) !== tree_1.JS.Kind.NamedImports) {
+        return undefined;
+    }
+    for (const elem of namedBindings.elements.elements) {
+        const specifierNode = elem.element.specifier;
+        if (!namedSpecifierImports(specifierNode, key)) {
+            continue;
+        }
+        if ((0, java_1.isIdentifier)(specifierNode)) {
+            return specifierNode.simpleName;
+        }
+        const alias = specifierNode.alias;
+        if ((0, java_1.isIdentifier)(alias)) {
+            return alias.simpleName;
+        }
+    }
+    return undefined;
+}
+/** Whether `specifier` imports the member `key`, under whatever local name it binds it to. */
+function namedSpecifierImports(specifier, key) {
+    if ((0, java_1.isIdentifier)(specifier)) {
+        return specifier.simpleName === key;
+    }
+    if (specifier.kind === tree_1.JS.Kind.Alias) {
+        const propertyName = specifier.propertyName.element;
+        return (0, java_1.isIdentifier)(propertyName) && propertyName.simpleName === key;
+    }
+    return false;
+}
+/** Whether the named specifier binding `key` carries its own inline `type`, as in `{type a, b}`. */
+function namedSpecifierIsTypeOnly(imp, key) {
+    var _a;
+    const namedBindings = (_a = imp.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings;
+    if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) !== tree_1.JS.Kind.NamedImports) {
+        return false;
+    }
+    for (const elem of namedBindings.elements.elements) {
+        if (namedSpecifierImports(elem.element.specifier, key)) {
+            return elem.element.importType.element;
+        }
+    }
+    return false;
+}
+/** How many named specifiers `jsImport` carries, `0` for a default, namespace or side-effect import. */
+function namedImportCount(jsImport) {
+    var _a;
+    const namedBindings = (_a = jsImport.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings;
+    return (namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.NamedImports ? namedBindings.elements.elements.length : 0;
+}
+/**
+ * Whether `jsImport`'s clause binds exactly one thing — a default, a namespace, or one named
+ * specifier. That is the only shape a module-only move can rewrite in place: whichever binding
+ * `importBinds` already matched is this one, so nothing else the clause carries goes along with it.
+ */
+function isOnlyMember(jsImport) {
+    var _a;
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return false;
+    }
+    const hasDefault = importClause.name !== undefined;
+    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;
+}
+/**
+ * The existing binding for `member` of `module`, read from `cu`'s own import statements — what
+ * `maybeRebind` reads before committing to a `RebindImport` edit.
+ */
+function existingImportBinding(cu, module, member) {
+    for (const stmt of cu.statements) {
+        const element = stmt.element;
+        if ((element === null || element === void 0 ? void 0 : element.kind) !== tree_1.JS.Kind.Import) {
+            continue;
+        }
+        const localName = importBinds(element, module, member);
+        if (localName !== undefined) {
+            return { localName, onlyMemberOfStatement: isOnlyMember(element) };
+        }
+    }
+    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.
+ */
+function aliasing(local, member) {
+    const propertyName = {
+        id: (0, uuid_1.randomId)(),
+        kind: java_1.J.Kind.Identifier,
+        prefix: java_1.emptySpace,
+        markers: markers_1.emptyMarkers,
+        annotations: [],
+        simpleName: member,
+        type: undefined,
+        fieldType: undefined
+    };
+    return {
+        id: (0, uuid_1.randomId)(),
+        kind: tree_1.JS.Kind.Alias,
+        prefix: local.prefix,
+        markers: markers_1.emptyMarkers,
+        propertyName: (0, java_1.rightPadded)(propertyName, java_1.singleSpace),
+        alias: Object.assign(Object.assign({}, local), { prefix: java_1.singleSpace })
+    };
+}
+/**
+ * Drops the binding for `member` from `jsImport`'s clause — the default, the namespace alias, or
+ * one entry of the named list, whichever `member` names — keeping everything else the clause
+ * binds. `ElementRemovalFormatter` carries the dropped binding's prefix onto whatever prints
+ * next, the same way `RemoveImport` keeps formatting sane when trimming a list.
+ */
+function removeBinding(jsImport, member) {
+    var _a;
+    const importClause = jsImport.importClause;
+    if (!importClause) {
+        return jsImport;
+    }
+    const key = memberName(member);
+    if (key === undefined) {
+        if (!importClause.name) {
+            return jsImport;
+        }
+        const namedBindings = importClause.namedBindings;
+        if ((namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === tree_1.JS.Kind.NamedImports) {
+            // `NamedImports` keeps the space before its own `{` on the container's `before`,
+            // not on its own prefix, so the removed default's prefix has to land there instead.
+            const namedImports = namedBindings;
+            const updated = Object.assign(Object.assign({}, namedImports), { elements: Object.assign(Object.assign({}, namedImports.elements), { before: importClause.name.element.prefix }) });
+            return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { name: undefined, namedBindings: updated }) });
+        }
+        if (namedBindings) {
+            const formatter = new java_1.ElementRemovalFormatter();
+            formatter.markRemoved(importClause.name.element);
+            return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { name: undefined, namedBindings: formatter.processKept(namedBindings) }) });
+        }
+        return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { name: undefined }) });
+    }
+    if (key === '*') {
+        return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: undefined }) });
+    }
+    if (((_a = importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) !== tree_1.JS.Kind.NamedImports) {
+        return jsImport;
+    }
+    const namedImports = importClause.namedBindings;
+    const formatter = new java_1.ElementRemovalFormatter();
+    const kept = [];
+    for (const entry of namedImports.elements.elements) {
+        if (namedSpecifierImports(entry.element.specifier, key)) {
+            formatter.markRemoved(entry.element);
+        }
+        else {
+            kept.push(Object.assign(Object.assign({}, entry), { element: formatter.processKept(entry.element) }));
+        }
+    }
+    if (kept.length === 0) {
+        // An emptied brace list still prints, as `import D, {} from "m"`, so it goes with its
+        // last member; the caller drops the whole statement when no default remains either.
+        return Object.assign(Object.assign({}, jsImport), { importClause: Object.assign(Object.assign({}, importClause), { namedBindings: undefined }) });
+    }
+    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 }) });
+}
+/**
+ * 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.
+ *
+ * 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) {
+        super();
+        this.from = from;
+        this.to = to;
+        this.localName = localName;
+        this.transformedInPlace = false;
+        this.typeOnly = false;
+    }
+    async visitJsCompilationUnit(cu, p) {
+        const visited = await super.visitJsCompilationUnit(cu, p);
+        if (!this.transformedInPlace) {
+            bindImport(this, {
+                module: this.to.module,
+                member: this.to.member,
+                alias: this.localName,
+                typeOnly: this.typeOnly,
+                onlyIfReferenced: false
+            });
+        }
+        return visited;
+    }
+    async visitImportDeclaration(jsImport, p) {
+        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) {
+            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));
+        if (!isOnlyMember(imp)) {
+            return removeBinding(imp, this.from.member);
+        }
+        this.transformedInPlace = true;
+        return (0, mutative_1.create)(imp, draft => {
+            var _a;
+            const literal = draft.moduleSpecifier.element;
+            literal.value = this.to.module;
+            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;
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+exports.RebindImport = RebindImport;
 //# sourceMappingURL=add-import.js.map