@openrewrite/rewrite 8.67.0-20251119-202228 → 8.67.0-20251120-093147

package/src/javascript/add-import.ts

@@ -13,23 +13,32 @@ export enum ImportStyle {
 }
 
 export interface AddImportOptions {
-    /** The module name (e.g., 'fs') to import from */
-    target: string;
+    /** The module name (e.g., 'fs', 'react') to import from */
+    module: string;
 
     /** Optionally, the specific member to import from the module.
      * If not specified, adds a default import or namespace import.
      * Special values:
-     * - 'default': Adds a default import from the target module.
-     *   When using 'default', the `alias` parameter is required. */
+     * - 'default': Adds a default import from the module.
+     *   When using 'default', the `alias` parameter is required.
+     * - '*': Adds a namespace import (import * as alias from 'module').
+     *   When using '*', the `alias` parameter is required.
+     * Cannot be combined with `sideEffectOnly`. */
     member?: string;
 
     /** Optional alias for the imported member.
-     * Required when member is 'default'. */
+     * Required when member is 'default' or '*'.
+     * Cannot be combined with `sideEffectOnly`. */
     alias?: string;
 
-    /** If true, only add the import if the member is actually used in the file. Default: true */
+    /** If true, only add the import if the member is actually used in the file. Default: true
+     * Cannot be combined with `sideEffectOnly`. */
     onlyIfReferenced?: boolean;
 
+    /** If true, adds a side-effect import without bindings (e.g., `import 'module'` or `require('module')`).
+     * Cannot be combined with `member`, `alias`, or `onlyIfReferenced`. */
+    sideEffectOnly?: boolean;
+
     /** Optional import style to use. If not specified, auto-detects from file and existing imports */
     style?: ImportStyle;
 }
@@ -41,15 +50,23 @@ export interface AddImportOptions {
  *
  * @example
  * // Add a named import
- * maybeAddImport(visitor, { target: 'fs', member: 'readFile' });
+ * maybeAddImport(visitor, { module: 'fs', member: 'readFile' });
  *
  * @example
  * // Add a default import using the 'default' member specifier
- * maybeAddImport(visitor, { target: 'react', member: 'default', alias: 'React' });
+ * maybeAddImport(visitor, { module: 'react', member: 'default', alias: 'React' });
  *
  * @example
  * // Add a default import (legacy way, without specifying member)
- * maybeAddImport(visitor, { target: 'react', alias: 'React' });
+ * maybeAddImport(visitor, { module: 'react', alias: 'React' });
+ *
+ * @example
+ * // Add a namespace import
+ * maybeAddImport(visitor, { module: 'crypto', member: '*', alias: 'crypto' });
+ *
+ * @example
+ * // Add a side-effect import
+ * maybeAddImport(visitor, { module: 'core-js/stable', sideEffectOnly: true });
  */
 export function maybeAddImport(
     visitor: JavaScriptVisitor<any>,
@@ -57,9 +74,10 @@ export function maybeAddImport(
 ) {
     for (const v of visitor.afterVisit || []) {
         if (v instanceof AddImport &&
-            v.target === options.target &&
+            v.module === options.module &&
             v.member === options.member &&
-            v.alias === options.alias) {
+            v.alias === options.alias &&
+            v.sideEffectOnly === (options.sideEffectOnly ?? false)) {
             return;
         }
     }
@@ -67,10 +85,11 @@ export function maybeAddImport(
 }
 
 export class AddImport<P> extends JavaScriptVisitor<P> {
-    readonly target: string;
+    readonly module: string;
     readonly member?: string;
     readonly alias?: string;
     readonly onlyIfReferenced: boolean;
+    readonly sideEffectOnly: boolean;
     readonly style?: ImportStyle;
 
     constructor(options: AddImportOptions) {
@@ -81,10 +100,29 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             throw new Error("When member is 'default', the alias parameter is required");
         }
 
-        this.target = options.target;
+        // Validate that alias is provided when member is '*' (namespace import)
+        if (options.member === '*' && !options.alias) {
+            throw new Error("When member is '*', the alias parameter is required");
+        }
+
+        // Validate that sideEffectOnly is not combined with incompatible options
+        if (options.sideEffectOnly) {
+            if (options.member !== undefined) {
+                throw new Error("Cannot combine sideEffectOnly with member");
+            }
+            if (options.alias !== undefined) {
+                throw new Error("Cannot combine sideEffectOnly with alias");
+            }
+            if (options.onlyIfReferenced !== undefined) {
+                throw new Error("Cannot combine sideEffectOnly with onlyIfReferenced");
+            }
+        }
+
+        this.module = options.module;
         this.member = options.member;
         this.alias = options.alias;
         this.onlyIfReferenced = options.onlyIfReferenced ?? true;
+        this.sideEffectOnly = options.sideEffectOnly ?? false;
         this.style = options.style;
     }
 
@@ -238,7 +276,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 if (moduleSpecifier) {
                     const moduleName = this.getModuleName(moduleSpecifier);
 
-                    if (moduleName === this.target) {
+                    if (moduleName === this.module) {
                         const importClause = jsImport.importClause;
                         if (importClause?.namedBindings) {
                             if (importClause.namedBindings.kind === JS.Kind.NamedImports) {
@@ -264,7 +302,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                     if (initializer?.kind === J.Kind.MethodInvocation &&
                         this.isRequireCall(initializer as J.MethodInvocation)) {
                         const moduleName = this.getModuleNameFromRequire(initializer as J.MethodInvocation);
-                        if (moduleName === this.target) {
+                        if (moduleName === this.module) {
                             return ImportStyle.CommonJS;
                         }
                     }
@@ -283,7 +321,8 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         }
 
         // If onlyIfReferenced is true, check if the identifier is actually used
-        if (this.onlyIfReferenced) {
+        // Skip this check for side-effect imports
+        if (!this.sideEffectOnly && this.onlyIfReferenced) {
             const isReferenced = await this.checkIdentifierReferenced(compilationUnit);
             if (!isReferenced) {
                 return compilationUnit;
@@ -294,8 +333,8 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         const importStyle = this.determineImportStyle(compilationUnit);
 
         // For ES6 named imports, check if we can merge into an existing import from the same module
-        // Don't try to merge default imports (member === 'default')
-        if (importStyle === ImportStyle.ES6Named && this.member !== undefined && this.member !== 'default') {
+        // Don't try to merge default imports (member === 'default'), side-effect imports, or namespace imports (member === '*')
+        if (!this.sideEffectOnly && importStyle === ImportStyle.ES6Named && this.member !== undefined && this.member !== 'default' && this.member !== '*') {
             const mergedCu = await this.tryMergeIntoExistingImport(compilationUnit, p);
             if (mergedCu !== compilationUnit) {
                 return mergedCu;
@@ -393,7 +432,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 const moduleName = this.getModuleName(moduleSpecifier);
 
                 // Check if this is an import from our target module
-                if (moduleName !== this.target) {
+                if (moduleName !== this.module) {
                     continue;
                 }
 
@@ -487,17 +526,44 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         }
 
         const moduleName = this.getModuleName(moduleSpecifier);
-        if (moduleName !== this.target) {
+        if (moduleName !== this.module) {
             return false;
         }
 
         const importClause = jsImport.importClause;
+
+        // Handle side-effect imports (no import clause)
         if (!importClause) {
+            // If we're trying to add a side-effect import and one already exists, it's a match
+            return this.sideEffectOnly;
+        }
+
+        // If we're adding a side-effect import but there's an existing import with bindings,
+        // it's not a match (side-effect import should be separate)
+        if (this.sideEffectOnly) {
             return false;
         }
 
         // Check if the specific member or default import already exists
-        if (this.member === undefined || this.member === 'default') {
+        if (this.member === '*') {
+            // We're adding a namespace import, check if one exists
+            const namedBindings = importClause.namedBindings;
+            if (!namedBindings) {
+                return false;
+            }
+
+            // Namespace imports can be represented as J.Identifier or JS.Alias
+            if (namedBindings.kind === J.Kind.Identifier) {
+                const identifier = namedBindings as J.Identifier;
+                return identifier.simpleName === this.alias;
+            } else if (namedBindings.kind === JS.Kind.Alias) {
+                const alias = namedBindings as JS.Alias;
+                if (alias.alias?.kind === J.Kind.Identifier) {
+                    return (alias.alias as J.Identifier).simpleName === this.alias;
+                }
+            }
+            return false;
+        } else if (this.member === undefined || this.member === 'default') {
             // We're adding a default import, check if one exists
             // For member === 'default', also verify the alias matches if specified
             if (importClause.name === undefined) {
@@ -559,7 +625,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         }
 
         const moduleName = this.getModuleNameFromRequire(methodInv);
-        if (moduleName !== this.target) {
+        if (moduleName !== this.module) {
             return false;
         }
 
@@ -610,8 +676,8 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         };
 
         // Create a visitor to collect used identifiers with their type attribution
-        const collector = new class extends JavaScriptVisitor<ExecutionContext> {
-            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+        const collector = new class extends JavaScriptVisitor<void> {
+            override async visitIdentifier(identifier: J.Identifier, p: void): Promise<J | undefined> {
                 const type = identifier.type;
                 if (type && Type.isMethod(type)) {
                     recordMethodUsage(type as Type.Method);
@@ -619,21 +685,21 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 return super.visitIdentifier(identifier, p);
             }
 
-            override async visitMethodInvocation(methodInvocation: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+            override async visitMethodInvocation(methodInvocation: J.MethodInvocation, p: void): Promise<J | undefined> {
                 if (methodInvocation.methodType) {
                     recordMethodUsage(methodInvocation.methodType);
                 }
                 return super.visitMethodInvocation(methodInvocation, p);
             }
 
-            override async visitFunctionCall(functionCall: JS.FunctionCall, p: ExecutionContext): Promise<J | undefined> {
+            override async visitFunctionCall(functionCall: JS.FunctionCall, p: void): Promise<J | undefined> {
                 if (functionCall.methodType) {
                     recordMethodUsage(functionCall.methodType);
                 }
                 return super.visitFunctionCall(functionCall, p);
             }
 
-            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: ExecutionContext): Promise<J | undefined> {
+            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: void): Promise<J | undefined> {
                 const type = fieldAccess.type;
                 if (type && Type.isMethod(type)) {
                     recordMethodUsage(type as Type.Method);
@@ -642,10 +708,19 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             }
         };
 
-        await collector.visit(compilationUnit, new ExecutionContext());
+        await collector.visit(compilationUnit, undefined);
+
+        // For namespace imports (member === '*'), we cannot use type attribution to detect usage
+        // because the namespace itself is used as an identifier, not individual members.
+        // We would need to traverse the AST looking for the alias identifier.
+        // For simplicity, we skip the onlyIfReferenced check for namespace imports.
+        if (this.member === '*') {
+            // TODO: Implement proper namespace usage detection by checking if alias identifier is used
+            return true;
+        }
 
         // Check if our target import is used based on type attribution
-        const moduleMembers = usedImports.get(this.target);
+        const moduleMembers = usedImports.get(this.module);
         if (!moduleMembers) {
             return false;
         }
@@ -662,20 +737,68 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         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
         const moduleSpecifier: J.Literal = {
             id: randomId(),
             kind: J.Kind.Literal,
-            prefix: singleSpace,
+            prefix: this.sideEffectOnly ? emptySpace : singleSpace,
             markers: emptyMarkers,
-            value: `'${this.target}'`,
-            valueSource: `'${this.target}'`,
+            value: `'${this.module}'`,
+            valueSource: `'${this.module}'`,
             unicodeEscapes: [],
             type: undefined
         };
 
         let importClause: JS.ImportClause | undefined;
 
-        if (this.member === undefined || this.member === 'default') {
+        if (this.sideEffectOnly) {
+            // Side-effect import: import 'module'
+            importClause = undefined;
+        } else if (this.member === '*') {
+            // Namespace import: import * as alias from 'module'
+            const propertyName: J.Identifier = {
+                id: randomId(),
+                kind: J.Kind.Identifier,
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                annotations: [],
+                simpleName: '*',
+                type: undefined,
+                fieldType: undefined
+            };
+
+            const aliasIdentifier: J.Identifier = {
+                id: randomId(),
+                kind: J.Kind.Identifier,
+                prefix: singleSpace,
+                markers: emptyMarkers,
+                annotations: [],
+                simpleName: this.alias!,
+                type: undefined,
+                fieldType: undefined
+            };
+
+            const namespaceBinding: JS.Alias = {
+                id: randomId(),
+                kind: JS.Kind.Alias,
+                prefix: singleSpace,
+                markers: emptyMarkers,
+                propertyName: rightPadded(propertyName, singleSpace),
+                alias: aliasIdentifier
+            };
+
+            importClause = {
+                id: randomId(),
+                kind: JS.Kind.ImportClause,
+                prefix: emptySpace,
+                markers: emptyMarkers,
+                typeOnly: false,
+                name: undefined,
+                namedBindings: namespaceBinding
+            };
+        } else if (this.member === undefined || this.member === 'default') {
             // Default import: import target from 'module'
             // or: import alias from 'module' (when member === 'default')
             const defaultName: J.Identifier = {
@@ -684,7 +807,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 prefix: singleSpace,
                 markers: emptyMarkers,
                 annotations: [],
-                simpleName: this.alias || this.target,
+                simpleName: this.alias || this.module,
                 type: undefined,
                 fieldType: undefined
             };

package/src/javascript/remove-import.ts

@@ -6,16 +6,16 @@ import {ElementRemovalFormatter} from "../java/formatting-utils";
 
 /**
  * @param visitor The visitor to add the import removal to
- * @param target Either the module name (e.g., 'fs') to remove specific members from,
- *               or the name of the import to remove entirely
+ * @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 the import matching `target`.
+ *               If not specified, removes all unused imports from the module.
  *               Special values:
- *               - 'default': Removes the default import from the target module if unused,
+ *               - '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 named import if unused
+ * // Remove a specific named import if unused
  * maybeRemoveImport(visitor, 'fs', 'readFile');
  *
  * @example
@@ -23,16 +23,20 @@ import {ElementRemovalFormatter} from "../java/formatting-utils";
  * maybeRemoveImport(visitor, 'react', 'default');
  *
  * @example
- * // Remove an import by name if unused (no module specified)
- * maybeRemoveImport(visitor, 'fs');
+ * // 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>, target: string, member?: string) {
+export function maybeRemoveImport(visitor: JavaScriptVisitor<any>, module: string, member?: string) {
     for (const v of visitor.afterVisit || []) {
-        if (v instanceof RemoveImport && v.target === target && v.member === member) {
+        if (v instanceof RemoveImport && v.module === module && v.member === member) {
             return;
         }
     }
-    visitor.afterVisit.push(new RemoveImport(target, member));
+    visitor.afterVisit.push(new RemoveImport(module, member));
 }
 
 // Type alias for RightPadded elements to simplify type signatures
@@ -45,15 +49,15 @@ type RightPaddedElement<T extends J> = {
 
 export class RemoveImport<P> extends JavaScriptVisitor<P> {
     /**
-     * @param target Either the module name (e.g., 'fs') to remove specific members from,
-     *               or the name of the import to remove entirely
+     * @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 the import matching `target`.
+     *               If not specified, removes all unused imports from the module.
      *               Special values:
-     *               - 'default': Removes the default import from the target module if unused,
+     *               - 'default': Removes the default import from the module if unused,
      *                 regardless of its local name
+     *               - '*': Removes the namespace import if unused
      */
-    constructor(readonly target: string,
+    constructor(readonly module: string,
                 readonly member?: string) {
         super();
     }
@@ -245,7 +249,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 const name = identifier.simpleName;
 
                 // Check if we should remove this default import
-                let shouldRemove = false;
+                let shouldRemove: boolean;
                 if (this.member === 'default') {
                     // Special case: member 'default' means remove any default import from the target module if unused
                     shouldRemove = !usedIdentifiers.has(name) && !usedTypes.has(name);
@@ -425,22 +429,17 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
      * Check if the module name matches the target module
      */
     private matchesTargetModule(moduleName: string): boolean {
-        return this.member === undefined ? moduleName === this.target : moduleName === this.target;
+        return moduleName === this.module;
     }
 
     /**
      * Check if an identifier should be removed based on usage
      */
     private shouldRemoveIdentifier(name: string, usedIdentifiers: Set<string>, usedTypes: Set<string>): boolean {
-        // If member is specified, we're removing a specific member
-        if (this.member !== undefined) {
-            // Only remove if the identifier is not used
-            return !usedIdentifiers.has(name) && !usedTypes.has(name);
-        } else {
-            // We're removing based on the target name
-            // Check if the name matches and is not used
-            return this.target === name && !usedIdentifiers.has(name) && !usedTypes.has(name);
-        }
+        // For CommonJS and import-equals-require, we're removing the entire import
+        // if the identifier is not used (member is typically undefined for these cases,
+        // or we're checking if a specific binding is used)
+        return !usedIdentifiers.has(name) && !usedTypes.has(name);
     }
 
     private async processNamedImports(
@@ -681,40 +680,32 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         usedIdentifiers: Set<string>,
         usedTypes: Set<string>
     ): boolean {
-        // If member is specified, we're removing a specific member from a module
+        // 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) {
                 return false;
             }
-        } else {
-            // If no member specified, we're removing based on the import name itself
-            if (this.target !== name) {
-                return false;
-            }
         }
+        // If no member specified, we're removing all unused imports from the module
+        // So we check if this particular import is unused
 
         // Check if it's used
         return !(usedIdentifiers.has(name) || usedTypes.has(name));
     }
 
     private isTargetModule(jsImport: JS.Import): boolean {
-        // If member is specified, we're looking for imports from a specific module
-        if (this.member !== undefined) {
-            const moduleSpecifier = jsImport.moduleSpecifier?.element;
-            if (!moduleSpecifier || moduleSpecifier.kind !== J.Kind.Literal) {
-                return false;
-            }
-
-            const literal = moduleSpecifier as J.Literal;
-            const moduleName = literal.value?.toString().replace(/['"`]/g, '');
-
-            // Match the module name
-            return moduleName === this.target;
+        // Always check if the import is from the specified module
+        const moduleSpecifier = jsImport.moduleSpecifier?.element;
+        if (!moduleSpecifier || moduleSpecifier.kind !== J.Kind.Literal) {
+            return false;
         }
 
-        // If no member specified, we process all imports to check their names
-        return true;
+        const literal = moduleSpecifier as J.Literal;
+        const moduleName = literal.value?.toString().replace(/['"`]/g, '');
+
+        // Match the module name
+        return moduleName === this.module;
     }
 
     /**