@openrewrite/rewrite 8.91.0 → 8.91.2

package/src/javascript/recipes/change-import.ts

@@ -18,9 +18,9 @@ import { Option, Recipe } from "../../recipe";
 import { TreeVisitor } from "../../visitor";
 import { ExecutionContext } from "../../execution";
 import { JavaScriptVisitor, JS } from "../index";
-import { maybeAddImport } from "../add-import";
-import { J, isIdentifier, Type } from "../../java";
-import { create as produce, Draft } from "mutative";
+import { maybeRebind } from "../binding";
+import { J, Type } from "../../java";
+import { create as produce } from "mutative";
 
 /**
  * Changes an import from one module to another, updating all type attributions.
@@ -41,7 +41,7 @@ import { create as produce, Draft } from "mutative";
  * // After:  import { act } from 'react';
  *
  * @example
- * // Change a named import to a different name
+ * // Change which member of the module a name is bound to
  * const recipe = new ChangeImport({
  *     oldModule: "lodash",
  *     oldMember: "extend",
@@ -49,7 +49,7 @@ import { create as produce, Draft } from "mutative";
  *     newMember: "assign"
  * });
  * // Before: import { extend } from 'lodash';
- * // After:  import { assign } from 'lodash';
+ * // After:  import { assign as extend } from 'lodash';
  */
 export class ChangeImport extends Recipe {
     readonly name = "org.openrewrite.javascript.change-import";
@@ -85,19 +85,11 @@ export class ChangeImport extends Recipe {
     })
     newMember?: string;
 
-    @Option({
-        displayName: "New alias",
-        description: "Optional alias for the new import. Required when newMember is 'default' or '*'.",
-        required: false
-    })
-    newAlias?: string;
-
     constructor(options?: {
         oldModule?: string;
         oldMember?: string;
         newModule?: string;
         newMember?: string;
-        newAlias?: string;
     }) {
         super(options);
     }
@@ -107,7 +99,6 @@ export class ChangeImport extends Recipe {
         const oldMember = this.oldMember;
         const newModule = this.newModule;
         const newMember = this.newMember ?? oldMember;
-        const newAlias = this.newAlias;
 
         // Build the old and new FQNs for type attribution updates
         const oldFqn = oldMember === 'default' || oldMember === '*'
@@ -119,185 +110,14 @@ export class ChangeImport extends Recipe {
 
         return new class extends JavaScriptVisitor<ExecutionContext> {
             private hasOldImport = false;
-            private oldAlias?: string;
-            private transformedImport = false;
 
             override async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
-                // Reset tracking for each file
-                this.hasOldImport = false;
-                this.oldAlias = undefined;
-                this.transformedImport = false;
-
-                // First pass: check if the old import exists and capture any alias
-                for (const statement of cu.statements) {
-                    const stmt = statement.element ?? statement;
-                    if (stmt.kind === JS.Kind.Import) {
-                        const jsImport = stmt as JS.Import;
-                        const aliasInfo = this.checkForOldImport(jsImport);
-                        if (aliasInfo.found) {
-                            this.hasOldImport = true;
-                            this.oldAlias = aliasInfo.alias;
-                            break;
-                        }
-                    }
-                }
-
-                // Visit the compilation unit (this will transform imports via visitJsImport)
-                let result = await super.visitJsCompilationUnit(cu, ctx) as JS.CompilationUnit;
-
-                // If we transformed an import but need to add to existing import from new module,
-                // or if we only removed a member from a multi-import, use maybeAddImport
-                if (this.hasOldImport && !this.transformedImport) {
-                    const aliasToUse = newAlias ?? this.oldAlias;
-
-                    if (newMember === 'default') {
-                        maybeAddImport(this, {
-                            module: newModule,
-                            member: 'default',
-                            alias: aliasToUse,
-                            onlyIfReferenced: false
-                        });
-                    } else if (newMember === '*') {
-                        maybeAddImport(this, {
-                            module: newModule,
-                            member: '*',
-                            alias: aliasToUse,
-                            onlyIfReferenced: false
-                        });
-                    } else if (aliasToUse && aliasToUse !== newMember) {
-                        maybeAddImport(this, {
-                            module: newModule,
-                            member: newMember,
-                            alias: aliasToUse,
-                            onlyIfReferenced: false
-                        });
-                    } else {
-                        maybeAddImport(this, {
-                            module: newModule,
-                            member: newMember,
-                            onlyIfReferenced: false
-                        });
-                    }
-                }
-
-                return result;
-            }
-
-            override async visitImportDeclaration(jsImport: JS.Import, ctx: ExecutionContext): Promise<J | undefined> {
-                let imp = await super.visitImportDeclaration(jsImport, ctx) as JS.Import;
-
-                if (!this.hasOldImport) {
-                    return imp;
-                }
-
-                const aliasInfo = this.checkForOldImport(imp);
-                if (!aliasInfo.found) {
-                    return imp;
-                }
-
-                // Check if this is the only import from the old module
-                const namedImports = this.getNamedImports(imp);
-                const isOnlyImport = namedImports.length === 1 ||
-                    (oldMember === 'default' && !imp.importClause?.namedBindings) ||
-                    (oldMember === '*');
-
-                if (isOnlyImport) {
-                    // Transform the module specifier in place
-                    this.transformedImport = true;
-                    return produce(imp, draft => {
-                        if (draft.moduleSpecifier) {
-                            const literal = draft.moduleSpecifier.element as Draft<J.Literal>;
-                            literal.value = newModule;
-                            // Update valueSource to preserve quote style
-                            const originalSource = literal.valueSource || `"${oldModule}"`;
-                            const quoteChar = originalSource.startsWith("'") ? "'" : '"';
-                            literal.valueSource = `${quoteChar}${newModule}${quoteChar}`;
-                        }
-                        // If we're also renaming the member, update the import specifier
-                        if (newMember !== oldMember && oldMember !== 'default' && oldMember !== '*') {
-                            const importClause = draft.importClause;
-                            if (importClause?.namedBindings?.kind === JS.Kind.NamedImports) {
-                                const namedImports = importClause.namedBindings as Draft<JS.NamedImports>;
-                                for (const elem of namedImports.elements.elements) {
-                                    const specifier = elem.element;
-                                    if (specifier.specifier.kind === J.Kind.Identifier &&
-                                        specifier.specifier.simpleName === oldMember) {
-                                        specifier.specifier.simpleName = newMember;
-                                    } else if (specifier.specifier.kind === JS.Kind.Alias) {
-                                        const aliasNode = specifier.specifier as Draft<JS.Alias>;
-                                        const propertyName = aliasNode.propertyName.element;
-                                        if (propertyName.kind === J.Kind.Identifier &&
-                                            propertyName.simpleName === oldMember) {
-                                            propertyName.simpleName = newMember;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    });
-                } else {
-                    // Remove just the specific member from the import
-                    // maybeAddImport will add the new import
-                    return this.removeNamedImportMember(imp, oldMember, ctx);
-                }
-            }
-
-            private async removeNamedImportMember(imp: JS.Import, memberToRemove: string, _ctx: ExecutionContext): Promise<JS.Import> {
-                return produce(imp, draft => {
-                    const importClause = draft.importClause;
-                    if (!importClause?.namedBindings) return;
-                    if (importClause.namedBindings.kind !== JS.Kind.NamedImports) return;
-
-                    const namedImports = importClause.namedBindings as Draft<JS.NamedImports>;
-                    const elements = namedImports.elements.elements;
-                    const filteredElements = elements.filter(elem => {
-                        const specifier = elem.element;
-                        const specifierNode = specifier.specifier;
-
-                        if (specifierNode.kind === J.Kind.Identifier) {
-                            return specifierNode.simpleName !== memberToRemove;
-                        }
-
-                        if (specifierNode.kind === JS.Kind.Alias) {
-                            const alias = specifierNode as JS.Alias;
-                            const propertyName = alias.propertyName.element;
-                            if (propertyName.kind === J.Kind.Identifier) {
-                                return propertyName.simpleName !== memberToRemove;
-                            }
-                        }
-
-                        return true;
-                    });
+                this.hasOldImport = maybeRebind(this, {
+                    from: {module: oldModule, member: oldMember},
+                    to: {module: newModule, member: newMember}
+                }) !== undefined;
 
-                    namedImports.elements.elements = filteredElements;
-                });
-            }
-
-            private getNamedImports(imp: JS.Import): string[] {
-                const imports: string[] = [];
-                const importClause = imp.importClause;
-                if (!importClause) return imports;
-
-                const namedBindings = importClause.namedBindings;
-                if (!namedBindings || namedBindings.kind !== JS.Kind.NamedImports) return imports;
-
-                const namedImports = namedBindings as JS.NamedImports;
-                for (const elem of namedImports.elements.elements) {
-                    const specifier = elem.element;
-                    const specifierNode = specifier.specifier;
-
-                    if (isIdentifier(specifierNode)) {
-                        imports.push(specifierNode.simpleName);
-                    } else if (specifierNode.kind === JS.Kind.Alias) {
-                        const alias = specifierNode as JS.Alias;
-                        const propertyName = alias.propertyName.element;
-                        if (isIdentifier(propertyName)) {
-                            imports.push(propertyName.simpleName);
-                        }
-                    }
-                }
-
-                return imports;
+                return super.visitJsCompilationUnit(cu, ctx);
             }
 
             override async visitIdentifier(identifier: J.Identifier, ctx: ExecutionContext): Promise<J | undefined> {
@@ -629,79 +449,6 @@ export class ChangeImport extends Recipe {
                 }
                 return arrayType;
             }
-
-            private checkForOldImport(jsImport: JS.Import): { found: boolean; alias?: string } {
-                // Check if this import is from the old module
-                const moduleSpecifier = jsImport.moduleSpecifier;
-                if (!moduleSpecifier) return { found: false };
-
-                const literal = moduleSpecifier.element;
-                if (literal.kind !== J.Kind.Literal) return { found: false };
-
-                const value = (literal as J.Literal).value;
-                if (value !== oldModule) return { found: false };
-
-                const importClause = jsImport.importClause;
-                if (!importClause) {
-                    // Side-effect import - not what we're looking for
-                    return { found: false };
-                }
-
-                // Check for default import
-                if (oldMember === 'default') {
-                    if (importClause.name) {
-                        const nameElem = importClause.name.element;
-                        if (isIdentifier(nameElem)) {
-                            return { found: true, alias: nameElem.simpleName };
-                        }
-                    }
-                    return { found: false };
-                }
-
-                // Check for namespace import
-                if (oldMember === '*') {
-                    const namedBindings = importClause.namedBindings;
-                    if (namedBindings?.kind === JS.Kind.Alias) {
-                        const alias = namedBindings as JS.Alias;
-                        if (isIdentifier(alias.alias)) {
-                            return { found: true, alias: alias.alias.simpleName };
-                        }
-                    }
-                    return { found: false };
-                }
-
-                // Check for named imports
-                const namedBindings = importClause.namedBindings;
-                if (!namedBindings) return { found: false };
-
-                if (namedBindings.kind !== JS.Kind.NamedImports) return { found: false };
-
-                const namedImports = namedBindings as JS.NamedImports;
-                const elements = namedImports.elements.elements;
-
-                for (const elem of elements) {
-                    const specifier = elem.element;
-                    const specifierNode = specifier.specifier;
-
-                    // Handle direct import: import { act }
-                    if (isIdentifier(specifierNode) && specifierNode.simpleName === oldMember) {
-                        return { found: true };
-                    }
-
-                    // Handle aliased import: import { act as something }
-                    if (specifierNode.kind === JS.Kind.Alias) {
-                        const alias = specifierNode as JS.Alias;
-                        const propertyName = alias.propertyName.element;
-                        if (isIdentifier(propertyName) && propertyName.simpleName === oldMember) {
-                            if (isIdentifier(alias.alias)) {
-                                return { found: true, alias: alias.alias.simpleName };
-                            }
-                        }
-                    }
-                }
-
-                return { found: false };
-            }
         }();
     }
 }

package/src/javascript/remove-import.ts

@@ -1,44 +1,10 @@
 import {JavaScriptVisitor} from "./visitor";
 import {J} from "../java";
+import {bindingNames} from "./scope";
 import {JS, JSX} from "./tree";
 import {mapAsync, updateIfChanged} from "../util";
 import {ElementRemovalFormatter} from "../java";
 
-/**
- * @param visitor The visitor to add the import removal to
- * @param module The module name (e.g., 'fs', 'react') to remove imports from
- * @param member Optionally, the specific member to remove from the import.
- *               If not specified, removes all unused imports from the module.
- *               Special values:
- *               - 'default': Removes the default import from the module if unused,
- *                 regardless of its local name (e.g., `import React from 'react'`)
- *               - '*': Removes the namespace import if unused (e.g., `import * as fs from 'fs'`)
- *
- * @example
- * // Remove a specific named import if unused
- * maybeRemoveImport(visitor, 'fs', 'readFile');
- *
- * @example
- * // Remove the default import from 'react' if unused (regardless of local name)
- * maybeRemoveImport(visitor, 'react', 'default');
- *
- * @example
- * // Remove all unused imports from 'react' module
- * maybeRemoveImport(visitor, 'react');
- *
- * @example
- * // Remove namespace import if unused
- * maybeRemoveImport(visitor, 'fs', '*');
- */
-export function maybeRemoveImport(visitor: JavaScriptVisitor<any>, module: string, member?: string) {
-    for (const v of visitor.afterVisit || []) {
-        if (v instanceof RemoveImport && v.module === module && v.member === member) {
-            return;
-        }
-    }
-    visitor.afterVisit.push(new RemoveImport(module, member));
-}
-
 // Type alias for RightPadded elements to simplify type signatures
 type RightPaddedElement<T extends J> = {
     element?: T;
@@ -268,7 +234,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                     shouldRemove = !usedIdentifiers.has(name) && !usedTypes.has(name);
                 } else {
                     // Regular case: check if the import name matches the removal criteria
-                    shouldRemove = this.shouldRemoveImport(name, usedIdentifiers, usedTypes);
+                    shouldRemove = this.shouldRemoveImport(name, usedIdentifiers, usedTypes, name);
                 }
 
                 if (shouldRemove) {
@@ -325,7 +291,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                         }, p);
                     }
                     // Namespace is used, we can't remove individual members from it
-                } else if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes)) {
+                } else if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes, name)) {
                     // If there's no default import, remove the entire import
                     if (!importClause.name) {
                         return undefined;
@@ -355,7 +321,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                         }, p);
                     }
                     // Namespace is used, we can't remove individual members from it
-                } else if (this.shouldRemoveImport(aliasName, usedIdentifiers, usedTypes)) {
+                } else if (this.shouldRemoveImport(aliasName, usedIdentifiers, usedTypes, aliasName)) {
                     // If there's no default import, remove the entire import
                     if (!importClause.name) {
                         return undefined;
@@ -490,7 +456,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                         return true; // Keep imports that don't match the member
                     } else {
                         // We're removing based on the import name itself
-                        return !this.shouldRemoveImport(importName, usedIdentifiers, usedTypes);
+                        return !this.shouldRemoveImport(importName, usedIdentifiers, usedTypes, importName);
                     }
                 }
                 return true; // Keep non-ImportSpecifier elements
@@ -612,14 +578,10 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         const {filtered, allRemoved} = await this.filterElementsWithPrefixPreservation(
             pattern.bindings.elements,
             (elem: J) => {
-                if (elem.kind === JS.Kind.BindingElement) {
-                    const name = this.getBindingElementName(elem as JS.BindingElement);
-                    return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
-                } else if (elem.kind === J.Kind.Identifier) {
-                    const name = (elem as J.Identifier).simpleName;
-                    return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
-                }
-                return true; // Keep other element types
+                const bound = this.boundByPatternElement(elem);
+                // An element whose names cannot be read is left alone.
+                return bound.length === 0 ||
+                    bound.some(b => !this.shouldRemoveImport(b.name, usedIdentifiers, new Set(), b.member));
             },
             async (elem: J, prefix: J.Space) => {
                 if (elem.kind === J.Kind.Identifier) {
@@ -687,23 +649,25 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         return undefined;
     }
 
-    private getBindingElementName(bindingElement: JS.BindingElement): string {
-        const name = bindingElement.name;
-        if (name?.kind === J.Kind.Identifier) {
-            return (name as J.Identifier).simpleName;
-        }
-        return '';
+    /** The names a pattern element binds, and for each the member of the module it reads. */
+    private boundByPatternElement(elem: J): { name: string; member?: string }[] {
+        // Shorthand, so the name it binds is the member it reads.
+        return elem.kind === J.Kind.Identifier
+            ? [{name: (elem as J.Identifier).simpleName, member: (elem as J.Identifier).simpleName}]
+            : bindingNames(elem);
     }
 
     private shouldRemoveImport(
         name: string,
         usedIdentifiers: Set<string>,
-        usedTypes: Set<string>
+        usedTypes: Set<string>,
+        member: string | undefined
     ): boolean {
         // If member is specified, we're removing a specific member from the module
         if (this.member !== undefined) {
-            // Only remove if this is the specific member we're looking for
-            if (this.member !== name) {
+            // A name bound under an alias reads one member and is referenced by another, and a name
+            // a nested pattern binds reads a property of a property, so it reads no member at all.
+            if (this.member !== member) {
                 return false;
             }
         }