@openrewrite/rewrite 8.91.4 → 8.91.6

package/src/javascript/remove-import.ts

@@ -1,6 +1,6 @@
 import {JavaScriptVisitor} from "./visitor";
 import {J} from "../java";
-import {bindingNames} from "./scope";
+import {bindingNames, namesReferencedWithin} from "./scope";
 import {JS, JSX} from "./tree";
 import {mapAsync, updateIfChanged} from "../util";
 import {ElementRemovalFormatter} from "../java";
@@ -101,14 +101,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
     }
 
     override async visitJsCompilationUnit(compilationUnit: JS.CompilationUnit, p: P): Promise<J | undefined> {
-        // First, collect all used identifiers in the file
-        const usedIdentifiers = new Set<string>();
-        const usedTypes = new Set<string>();
-
-        // Traverse the AST to collect used identifiers
-        await this.collectUsedIdentifiers(compilationUnit, usedIdentifiers, usedTypes);
-
-        // Now process imports with knowledge of what's used
+        const usedNames = collectUsedNames(compilationUnit);
         return this.produceJavaScript(compilationUnit, p, async draft => {
             const formatter = new ElementRemovalFormatter<J>(true); // Preserve file headers from first import
 
@@ -118,7 +111,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 // Handle ES6 imports
                 if (statement?.kind === JS.Kind.Import) {
                     const jsImport = statement as JS.Import;
-                    const result = await this.processImport(jsImport, usedIdentifiers, usedTypes, p);
+                    const result = await this.processImport(jsImport, usedNames, p);
                     if (result === undefined) {
                         formatter.markRemoved(statement);
                         return undefined;
@@ -133,7 +126,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 // Multi-variable declarations might come as JS.ScopedVariableDeclarations
                 if (statement?.kind === J.Kind.VariableDeclarations) {
                     const varDecl = statement as J.VariableDeclarations;
-                    const result = await this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
+                    const result = await this.processRequireFromVarDecls(varDecl, usedNames, p);
                     if (result === undefined) {
                         formatter.markRemoved(statement);
                         return undefined;
@@ -154,7 +147,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                     for (const v of scopedVarDecl.variables) {
                         const varDecl = v.element;
                         if (varDecl?.kind === J.Kind.VariableDeclarations) {
-                            const result = await this.processRequireFromVarDecls(varDecl as J.VariableDeclarations, usedIdentifiers, p);
+                            const result = await this.processRequireFromVarDecls(varDecl as J.VariableDeclarations, usedNames, p);
                             if (result === undefined) {
                                 hasChanges = true;
                                 varFormatter.markRemoved(varDecl);
@@ -197,13 +190,12 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
 
     private async processImport(
         jsImport: JS.Import,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>,
+        usedNames: Set<string>,
         p: P
     ): Promise<JS.Import | undefined> {
         // Handle import-equals-require syntax: import util = require("util");
         if (jsImport.initializer) {
-            return this.processImportEqualsRequire(jsImport, usedIdentifiers, usedTypes, p);
+            return this.processImportEqualsRequire(jsImport, usedNames, p);
         }
 
         // Check if this import is from the target module
@@ -231,10 +223,10 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 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);
+                    shouldRemove = !usedNames.has(name);
                 } else {
                     // Regular case: check if the import name matches the removal criteria
-                    shouldRemove = this.shouldRemoveImport(name, usedIdentifiers, usedTypes, name);
+                    shouldRemove = this.shouldRemoveImport(name, usedNames, name);
                 }
 
                 if (shouldRemove) {
@@ -281,7 +273,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 if (this.member !== undefined) {
                     // We're trying to remove a specific member from this namespace
                     // Check if the namespace itself is used
-                    if (!usedIdentifiers.has(name) && !usedTypes.has(name)) {
+                    if (!usedNames.has(name)) {
                         // Namespace is not used, remove the entire import
                         if (!importClause.name) {
                             return undefined;
@@ -291,7 +283,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, name)) {
+                } else if (this.shouldRemoveImport(name, usedNames, name)) {
                     // If there's no default import, remove the entire import
                     if (!importClause.name) {
                         return undefined;
@@ -311,7 +303,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 if (this.member !== undefined) {
                     // We're trying to remove a specific member from this namespace
                     // Check if the namespace itself is used
-                    if (!usedIdentifiers.has(aliasName) && !usedTypes.has(aliasName)) {
+                    if (!usedNames.has(aliasName)) {
                         // Namespace is not used, remove the entire import
                         if (!importClause.name) {
                             return undefined;
@@ -321,7 +313,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, aliasName)) {
+                } else if (this.shouldRemoveImport(aliasName, usedNames, aliasName)) {
                     // If there's no default import, remove the entire import
                     if (!importClause.name) {
                         return undefined;
@@ -336,7 +328,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
             // Handle named imports: import { a, b } from 'module'
             if (namedBindings.kind === JS.Kind.NamedImports) {
                 const namedImports = namedBindings as JS.NamedImports;
-                const updatedImports = await this.processNamedImports(namedImports, usedIdentifiers, usedTypes, p);
+                const updatedImports = await this.processNamedImports(namedImports, usedNames, p);
 
                 if (updatedImports === undefined) {
                     // All named imports were removed
@@ -366,12 +358,11 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
      */
     private async processImportEqualsRequire(
         jsImport: JS.Import,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>,
+        usedNames: Set<string>,
         p: P
     ): Promise<JS.Import | undefined> {
         const initializer = jsImport.initializer?.element;
-        if (!initializer || !this.isRequireCall(initializer)) {
+        if (!initializer || !isRequireCall(initializer)) {
             return jsImport;
         }
 
@@ -392,25 +383,13 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
 
         // For import-equals-require, we can only remove the entire import since
         // it imports the whole module as a single identifier
-        if (this.shouldRemoveIdentifier(importedName, usedIdentifiers, usedTypes)) {
+        if (this.shouldRemoveIdentifier(importedName, usedNames)) {
             return undefined;
         }
 
         return jsImport;
     }
 
-    /**
-     * Check if a node is a require() method invocation
-     */
-    private isRequireCall(node: J): boolean {
-        if (node.kind !== J.Kind.MethodInvocation) {
-            return false;
-        }
-        const methodInv = node as J.MethodInvocation;
-        return methodInv.name?.kind === J.Kind.Identifier &&
-               (methodInv.name as J.Identifier).simpleName === 'require';
-    }
-
     /**
      * Check if the module name matches the target module
      */
@@ -421,17 +400,16 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
     /**
      * Check if an identifier should be removed based on usage
      */
-    private shouldRemoveIdentifier(name: string, usedIdentifiers: Set<string>, usedTypes: Set<string>): boolean {
+    private shouldRemoveIdentifier(name: string, usedNames: Set<string>): boolean {
         // 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);
+        return !usedNames.has(name);
     }
 
     private async processNamedImports(
         namedImports: JS.NamedImports,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>,
+        usedNames: Set<string>,
         p: P
     ): Promise<JS.NamedImports | undefined> {
         const {filtered, allRemoved} = await this.filterElementsWithPrefixPreservation(
@@ -451,12 +429,12 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                         // We're removing a specific member - check if this matches
                         if (this.member === importName) {
                             // This is the member we want to remove - check if it's used
-                            return usedIdentifiers.has(nameToCheck) || usedTypes.has(nameToCheck);
+                            return usedNames.has(nameToCheck);
                         }
                         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, importName);
+                        return !this.shouldRemoveImport(importName, usedNames, importName);
                     }
                 }
                 return true; // Keep non-ImportSpecifier elements
@@ -493,7 +471,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
 
     private async processRequireFromVarDecls(
         varDecls: J.VariableDeclarations,
-        usedIdentifiers: Set<string>,
+        usedNames: Set<string>,
         p: P
     ): Promise<J.VariableDeclarations | undefined> {
         // Check if this is a require() call
@@ -507,7 +485,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         }
 
         const initializer = namedVar.initializer?.element;
-        if (!initializer || !this.isRequireCall(initializer)) {
+        if (!initializer || !isRequireCall(initializer)) {
             return varDecls;
         }
 
@@ -525,7 +503,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
 
             // For require() statements, check the module name from the require call
             const moduleName = this.getModuleNameFromRequire(methodInv);
-            if (moduleName && this.matchesTargetModule(moduleName) && !usedIdentifiers.has(varName)) {
+            if (moduleName && this.matchesTargetModule(moduleName) && !usedNames.has(varName)) {
                 return undefined; // Remove the entire require statement
             }
         }
@@ -533,7 +511,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         // Handle: const { readFile } = require('fs')
         if (pattern.kind === JS.Kind.ObjectBindingPattern && this.member !== undefined) {
             const objectPattern = pattern as JS.ObjectBindingPattern;
-            const updatedPattern = await this.processObjectBindingPattern(objectPattern, usedIdentifiers, p);
+            const updatedPattern = await this.processObjectBindingPattern(objectPattern, usedNames, p);
 
             if (updatedPattern === undefined) {
                 return undefined; // Remove entire require
@@ -572,7 +550,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
 
     private async processObjectBindingPattern(
         pattern: JS.ObjectBindingPattern,
-        usedIdentifiers: Set<string>,
+        usedNames: Set<string>,
         p: P
     ): Promise<JS.ObjectBindingPattern | undefined> {
         const {filtered, allRemoved} = await this.filterElementsWithPrefixPreservation(
@@ -581,7 +559,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
                 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));
+                    bound.some(b => !this.shouldRemoveImport(b.name, usedNames, b.member));
             },
             async (elem: J, prefix: J.Space) => {
                 if (elem.kind === J.Kind.Identifier) {
@@ -659,8 +637,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
 
     private shouldRemoveImport(
         name: string,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>,
+        usedNames: Set<string>,
         member: string | undefined
     ): boolean {
         // If member is specified, we're removing a specific member from the module
@@ -675,7 +652,7 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         // So we check if this particular import is unused
 
         // Check if it's used
-        return !(usedIdentifiers.has(name) || usedTypes.has(name));
+        return !usedNames.has(name);
     }
 
     private isTargetModule(jsImport: JS.Import): boolean {
@@ -692,379 +669,28 @@ export class RemoveImport<P> extends JavaScriptVisitor<P> {
         return moduleName === this.module;
     }
 
-    /**
-     * Helper to traverse parameters from various node types
-     */
-    private async traverseParameters(
-        params: any,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>
-    ): Promise<void> {
-        if (!params || typeof params !== 'object') return;
-
-        if (Array.isArray(params)) {
-            for (const p of params) {
-                // Array elements might be RightPadded, so unwrap them
-                const elem = (p as any).element || p;
-                await this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
-            }
-        } else if (params.elements) {
-            for (const p of params.elements) {
-                if (p.element) {
-                    await this.collectUsedIdentifiers(p.element, usedIdentifiers, usedTypes);
-                }
-            }
-        } else if (params.parameters) {
-            for (const p of params.parameters) {
-                const elem = p.element || p;
-                await this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
-            }
-        }
-    }
-
-    /**
-     * Helper to traverse statements from various node types
-     */
-    private async traverseStatements(
-        statements: any,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>
-    ): Promise<void> {
-        if (!statements) return;
-
-        if (Array.isArray(statements)) {
-            for (const stmt of statements) {
-                const element = stmt.element || stmt;
-                if (element) {
-                    await this.collectUsedIdentifiers(element, usedIdentifiers, usedTypes);
-                }
-            }
-        }
-    }
-
-    /**
-     * Helper to check for type expressions and collect type usage
-     */
-    private async checkTypeExpression(
-        node: any,
-        usedTypes: Set<string>
-    ): Promise<void> {
-        if (node.typeExpression) {
-            await this.collectTypeUsage(node.typeExpression, usedTypes);
-        }
-    }
+}
 
-    private async collectUsedIdentifiers(
-        node: J,
-        usedIdentifiers: Set<string>,
-        usedTypes: Set<string>
-    ): Promise<void> {
-        // This is a simplified version - in a real implementation,
-        // we'd need to traverse the entire AST and collect all identifier usages
-        // For now, we'll implement a basic traversal
-
-        if (node.kind === J.Kind.Identifier) {
-            const identifier = node as J.Identifier;
-            usedIdentifiers.add(identifier.simpleName);
-        } else if (node.kind === J.Kind.VariableDeclarations) {
-            const varDecls = node as J.VariableDeclarations;
-            // Check the type expression on the VariableDeclarations itself
-            await this.checkTypeExpression(varDecls, usedTypes);
-            for (const v of varDecls.variables) {
-                // Check the initializer
-                if (v.element.initializer?.element) {
-                    await this.collectUsedIdentifiers(v.element.initializer.element, usedIdentifiers, usedTypes);
-                }
-            }
-        } else if (node.kind === J.Kind.MethodInvocation) {
-            const methodInv = node as J.MethodInvocation;
-
-            // Check if this is a member access pattern like fs.readFileSync
-            if (methodInv.select?.element?.kind === J.Kind.FieldAccess) {
-                const fieldAccess = methodInv.select.element as J.FieldAccess;
-                if (fieldAccess.target?.kind === J.Kind.Identifier) {
-                    usedIdentifiers.add((fieldAccess.target as J.Identifier).simpleName);
-                }
-            } else if (methodInv.select?.element?.kind === J.Kind.Identifier) {
-                // Direct identifier like fs in fs.method() - though this is rare
-                usedIdentifiers.add((methodInv.select.element as J.Identifier).simpleName);
-            } else if (!methodInv.select) {
-                // No select means this is a direct function call like isArray()
-                // Only in this case should we add the method name as a used identifier
-                if (methodInv.name && methodInv.name.kind === J.Kind.Identifier) {
-                    usedIdentifiers.add((methodInv.name as J.Identifier).simpleName);
-                }
-            }
-            // Note: We don't add method names for calls like Array.isArray() or obj.method()
-            // because those are methods on objects, not standalone imported functions
-            // Recursively check arguments
-            if (methodInv.arguments) {
-                for (const arg of methodInv.arguments.elements) {
-                    if (arg.element) {
-                        await this.collectUsedIdentifiers(arg.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            // Check select (object being called on)
-            if (methodInv.select?.element) {
-                await this.collectUsedIdentifiers(methodInv.select.element, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === J.Kind.MemberReference) {
-            const memberRef = node as J.MemberReference;
-            if (memberRef.containing && memberRef.containing.element?.kind === J.Kind.Identifier) {
-                usedIdentifiers.add((memberRef.containing.element as J.Identifier).simpleName);
-            }
-        } else if (node.kind === J.Kind.FieldAccess) {
-            // Handle field access like fs.readFileSync
-            const fieldAccess = node as J.FieldAccess;
-            if (fieldAccess.target?.kind === J.Kind.Identifier) {
-                usedIdentifiers.add((fieldAccess.target as J.Identifier).simpleName);
-            }
-            // Recursively check the target
-            if (fieldAccess.target) {
-                await this.collectUsedIdentifiers(fieldAccess.target, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.CompilationUnit) {
-            const cu = node as JS.CompilationUnit;
-            for (const stmt of cu.statements) {
-                if (stmt.element && stmt.element.kind !== JS.Kind.Import) {
-                    // Skip require() statements at the top level
-                    if (stmt.element.kind === J.Kind.VariableDeclarations) {
-                        const varDecls = stmt.element as J.VariableDeclarations;
-                        // Check if this is a require() statement
-                        let isRequire = false;
-                        for (const v of varDecls.variables) {
-                            const namedVar = v.element;
-                            if (namedVar?.initializer?.element?.kind === J.Kind.MethodInvocation) {
-                                const methodInv = namedVar.initializer.element as J.MethodInvocation;
-                                if (methodInv.name?.kind === J.Kind.Identifier &&
-                                    (methodInv.name as J.Identifier).simpleName === 'require') {
-                                    isRequire = true;
-                                    break;
-                                }
-                            }
-                        }
-                        if (!isRequire) {
-                            // Not a require statement, process normally
-                            await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                        }
-                    } else if (stmt.element.kind !== JS.Kind.ScopedVariableDeclarations) {
-                        // Process other non-import, non-require statements normally
-                        await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-        } else if (node.kind === J.Kind.Return) {
-            // Handle return statements
-            const returnStmt = node as J.Return;
-            if (returnStmt.expression) {
-                await this.collectUsedIdentifiers(returnStmt.expression, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === J.Kind.Block) {
-            const block = node as J.Block;
-            for (const stmt of block.statements) {
-                if (stmt.element) {
-                    await this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
-                }
-            }
-        } else if (node.kind === J.Kind.MethodDeclaration) {
-            const method = node as J.MethodDeclaration;
-            // Check parameters for type usage
-            if (method.parameters) {
-                for (const param of method.parameters.elements) {
-                    // Parameters can be various types, handle them recursively
-                    if (param.element) {
-                        await this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            // Check body
-            if (method.body) {
-                await this.collectUsedIdentifiers(method.body, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.TypeOf) {
-            // Handle typeof expressions like: typeof util
-            const typeOf = node as JS.TypeOf;
-            if (typeOf.expression) {
-                await this.collectUsedIdentifiers(typeOf.expression, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.TypeQuery) {
-            // Handle typeof type queries like: const x: typeof util
-            const typeQuery = node as JS.TypeQuery;
-            if (typeQuery.typeExpression) {
-                await this.collectUsedIdentifiers(typeQuery.typeExpression, usedIdentifiers, usedTypes);
-            }
-        } else if ((node as any).typeExpression) {
-            // Handle nodes with type expressions (parameters, variables, etc.)
-            await this.checkTypeExpression(node, usedTypes);
-            // Continue traversing other parts
-            if ((node as any).name) {
-                await this.collectUsedIdentifiers((node as any).name, usedIdentifiers, usedTypes);
-            }
-            if ((node as any).initializer) {
-                await this.collectUsedIdentifiers((node as any).initializer, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.ArrowFunction || node.kind === J.Kind.Lambda) {
-            // Handle arrow functions and lambdas
-            const func = node as any;
-            if (func.parameters) {
-                await this.collectUsedIdentifiers(func.parameters, usedIdentifiers, usedTypes);
-            }
-            if (func.lambda) {
-                await this.collectUsedIdentifiers(func.lambda, usedIdentifiers, usedTypes);
-            }
-            if (func.body) {
-                await this.collectUsedIdentifiers(func.body, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === J.Kind.Lambda) {
-            const lambda = node as J.Lambda;
-            if (lambda.parameters?.parameters) {
-                for (const param of lambda.parameters.parameters) {
-                    if (param.element) {
-                        await this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            if (lambda.body) {
-                await this.collectUsedIdentifiers(lambda.body, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.JsxTag) {
-            // Handle JSX tags like <div>content</div>
-            const jsxTag = node as JSX.Tag;
-            // Check attributes
-            if (jsxTag.attributes) {
-                for (const attr of jsxTag.attributes) {
-                    if (attr.element) {
-                        await this.collectUsedIdentifiers(attr.element, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-            // Check children
-            if (jsxTag.children) {
-                for (const child of jsxTag.children) {
-                    if (child) {
-                        await this.collectUsedIdentifiers(child, usedIdentifiers, usedTypes);
-                    }
-                }
-            }
-        } else if (node.kind === JS.Kind.JsxEmbeddedExpression) {
-            // Handle JSX embedded expressions like {React.version}
-            const embedded = node as JSX.EmbeddedExpression;
-            // The expression is wrapped in RightPadded, so unwrap it
-            const expr = embedded.expression?.element || embedded.expression;
-            if (expr) {
-                await this.collectUsedIdentifiers(expr, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.JsxAttribute) {
-            // Handle JSX attributes like onClick={handler}
-            const jsxAttr = node as any;
-            if (jsxAttr.value) {
-                await this.collectUsedIdentifiers(jsxAttr.value, usedIdentifiers, usedTypes);
-            }
-        } else if (node.kind === JS.Kind.TypeDeclaration) {
-            // Handle type alias declarations like: type Props = { children: React.ReactNode }
-            const typeDecl = node as JS.TypeDeclaration;
-            // The initializer contains the type expression (the right side of the =)
-            if (typeDecl.initializer?.element) {
-                await this.collectTypeUsage(typeDecl.initializer.element, usedTypes);
-            }
-        } else if ((node as any).statements) {
-            // Generic handler for nodes with statements
-            await this.traverseStatements((node as any).statements, usedIdentifiers, usedTypes);
-        } else if ((node as any).body) {
-            // Generic handler for nodes with body
-            await this.collectUsedIdentifiers((node as any).body, usedIdentifiers, usedTypes);
-        } else if ((node as any).parameters) {
-            // Handle anything with parameters (functions, methods, etc.)
-            await this.traverseParameters((node as any).parameters, usedIdentifiers, usedTypes);
-            // Continue with the body if it exists
-            if ((node as any).body) {
-                await this.collectUsedIdentifiers((node as any).body, usedIdentifiers, usedTypes);
-            }
-        }
+/**
+ * The names the file references, less its own imports: a specifier names what it binds, so counting
+ * one would read an import as a use of itself.
+ */
+function collectUsedNames(cu: JS.CompilationUnit): Set<string> {
+    const used = new Set<string>();
+    for (const statement of cu.statements) {
+        const element = statement.element;
+        if (!element || element.kind === JS.Kind.Import) {
+            continue;
+        }
+        namesReferencedWithin(element).forEach(name => used.add(name));
     }
+    return used;
+}
 
-    private async collectTypeUsage(typeExpr: J, usedTypes: Set<string>): Promise<void> {
-        if (typeExpr.kind === J.Kind.Identifier) {
-            usedTypes.add((typeExpr as J.Identifier).simpleName);
-        } else if (typeExpr.kind === J.Kind.ParameterizedType) {
-            const paramType = typeExpr as J.ParameterizedType;
-            // First, collect usage from the base type (e.g., React.Ref from React.Ref<T>)
-            if (paramType.class) {
-                await this.collectTypeUsage(paramType.class, usedTypes);
-            }
-            // Then collect usage from type parameters (e.g., HTMLButtonElement from React.Ref<HTMLButtonElement>)
-            if (paramType.typeParameters) {
-                for (const typeParam of paramType.typeParameters.elements) {
-                    if (typeParam.element) {
-                        await this.collectTypeUsage(typeParam.element, usedTypes);
-                    }
-                }
-            }
-        } else if (typeExpr.kind === J.Kind.FieldAccess) {
-            // Handle qualified names in type positions like React.Ref
-            const fieldAccess = typeExpr as J.FieldAccess;
-            if (fieldAccess.target?.kind === J.Kind.Identifier) {
-                usedTypes.add((fieldAccess.target as J.Identifier).simpleName);
-            } else if (fieldAccess.target) {
-                // Recursively handle nested field accesses
-                await this.collectTypeUsage(fieldAccess.target, usedTypes);
-            }
-        } else if (typeExpr.kind === JS.Kind.Intersection) {
-            // Handle intersection types like ButtonProps & { ref?: React.Ref<HTMLButtonElement> }
-            const intersection = typeExpr as JS.Intersection;
-            for (const typeElem of intersection.types) {
-                if (typeElem.element) {
-                    await this.collectTypeUsage(typeElem.element, usedTypes);
-                }
-            }
-        } else if (typeExpr.kind === JS.Kind.TypeLiteral) {
-            // Handle type literals like { ref?: React.Ref<HTMLButtonElement> }
-            const typeLiteral = typeExpr as JS.TypeLiteral;
-            // TypeLiteral members are in a Block, which contains statements
-            for (const stmt of typeLiteral.members.statements) {
-                if (stmt.element) {
-                    // Each statement is typically a VariableDeclarations representing a property
-                    await this.collectUsedIdentifiers(stmt.element, new Set(), usedTypes);
-                }
-            }
-        } else if (typeExpr.kind === JS.Kind.TypeQuery) {
-            // Handle typeof type queries like: const x: typeof util
-            const typeQuery = typeExpr as JS.TypeQuery;
-            if (typeQuery.typeExpression) {
-                await this.collectTypeUsage(typeQuery.typeExpression, usedTypes);
-            }
-        } else if (typeExpr.kind === JS.Kind.TypeOf) {
-            // Handle typeof expressions in types
-            const typeOf = typeExpr as JS.TypeOf;
-            if (typeOf.expression) {
-                // For typeof expressions, the expression contains the identifier
-                // Add it to usedTypes since it's used in a type context
-                if (typeOf.expression.kind === J.Kind.Identifier) {
-                    usedTypes.add((typeOf.expression as J.Identifier).simpleName);
-                } else {
-                    await this.collectTypeUsage(typeOf.expression, usedTypes);
-                }
-            }
-        } else if (typeExpr.kind === JS.Kind.TypeTreeExpression) {
-            // Handle TypeTreeExpression which wraps type identifiers
-            const typeTree = typeExpr as JS.TypeTreeExpression;
-            if (typeTree.expression) {
-                await this.collectTypeUsage(typeTree.expression, usedTypes);
-            }
-        } else if (typeExpr.kind === JS.Kind.TypeInfo) {
-            // Handle TypeInfo which contains type identifiers
-            const typeInfo = typeExpr as JS.TypeInfo;
-            if (typeInfo.typeIdentifier) {
-                await this.collectTypeUsage(typeInfo.typeIdentifier, usedTypes);
-            }
-        } else if ((typeExpr as any).expression) {
-            // Generic handler for nodes with expression property
-            await this.collectTypeUsage((typeExpr as any).expression, usedTypes);
-        } else if ((typeExpr as any).typeIdentifier) {
-            // Generic handler for nodes with typeIdentifier property
-            await this.collectTypeUsage((typeExpr as any).typeIdentifier, usedTypes);
-        }
-        // Add more type expression handlers as needed
+function isRequireCall(node: J): boolean {
+    if (node.kind !== J.Kind.MethodInvocation) {
+        return false;
     }
+    const name = (node as J.MethodInvocation).name;
+    return name?.kind === J.Kind.Identifier && (name as J.Identifier).simpleName === 'require';
 }