@openrewrite/rewrite 8.62.4 → 8.62.6

package/dist/javascript/remove-import.js

@@ -0,0 +1,715 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveImport = void 0;
+exports.maybeRemoveImport = maybeRemoveImport;
+const visitor_1 = require("./visitor");
+const java_1 = require("../java");
+const tree_1 = require("./tree");
+const util_1 = require("../util");
+/**
+ * @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 member Optionally, the specific member to remove from the import.
+ *               If not specified, removes the import matching `target`
+ */
+function maybeRemoveImport(visitor, target, member) {
+    for (const v of visitor.afterVisit || []) {
+        if (v instanceof RemoveImport && v.target === target && v.member === member) {
+            return;
+        }
+    }
+    visitor.afterVisit.push(new RemoveImport(target, member));
+}
+class RemoveImport extends visitor_1.JavaScriptVisitor {
+    /**
+     * @param target Either the module name (e.g., 'fs') to remove specific members from,
+     *               or the name of the import to remove entirely
+     * @param member Optionally, the specific member to remove from the import.
+     *               If not specified, removes the import matching `target`
+     */
+    constructor(target, member) {
+        super();
+        this.target = target;
+        this.member = member;
+    }
+    /**
+     * Generic helper to filter elements from a RightPadded array while preserving formatting.
+     * When removing elements, the prefix from the first removed element is applied to the
+     * first remaining element to maintain proper spacing.
+     */
+    filterElementsWithPrefixPreservation(elements, shouldKeep, updatePrefix, _p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const filtered = [];
+            let removedPrefix;
+            for (const elem of elements) {
+                if (elem.element && shouldKeep(elem.element)) {
+                    // If we removed the previous element and this is the first kept element,
+                    // apply the removed element's prefix to maintain formatting
+                    if (removedPrefix && filtered.length === 0) {
+                        const updatedElement = yield updatePrefix(elem.element, removedPrefix);
+                        filtered.push(Object.assign(Object.assign({}, elem), { element: updatedElement }));
+                        removedPrefix = undefined;
+                    }
+                    else {
+                        filtered.push(elem);
+                    }
+                }
+                else if (elem.element) {
+                    // Store the prefix of the first removed element
+                    if (filtered.length === 0 && !removedPrefix) {
+                        removedPrefix = elem.element.prefix;
+                    }
+                }
+                else {
+                    // Keep non-element entries (shouldn't happen but be safe)
+                    filtered.push(elem);
+                }
+            }
+            return {
+                filtered,
+                allRemoved: filtered.length === 0
+            };
+        });
+    }
+    /**
+     * Helper to update an import clause by removing specific bindings
+     */
+    updateImportClause(jsImport, importClause, updateFn, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.produceJavaScript(jsImport, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                if (draft.importClause) {
+                    draft.importClause = yield this.produceJavaScript(importClause, p, (clauseDraft) => __awaiter(this, void 0, void 0, function* () { return updateFn(clauseDraft); }));
+                }
+            }));
+        });
+    }
+    visitJsCompilationUnit(compilationUnit, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // First, collect all used identifiers in the file
+            const usedIdentifiers = new Set();
+            const usedTypes = new Set();
+            // Traverse the AST to collect used identifiers
+            yield this.collectUsedIdentifiers(compilationUnit, usedIdentifiers, usedTypes);
+            // Now process imports with knowledge of what's used
+            return this.produceJavaScript(compilationUnit, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                let nextStatementPrefix;
+                draft.statements = yield (0, util_1.mapAsync)(compilationUnit.statements, (stmt, index) => __awaiter(this, void 0, void 0, function* () {
+                    const statement = stmt.element;
+                    // Handle ES6 imports
+                    if ((statement === null || statement === void 0 ? void 0 : statement.kind) === tree_1.JS.Kind.Import) {
+                        const jsImport = statement;
+                        const result = yield this.processImport(jsImport, usedIdentifiers, usedTypes, p);
+                        if (result === undefined) {
+                            // Store the prefix for the next statement to avoid leaving blank lines
+                            if (index < compilationUnit.statements.length - 1) {
+                                const nextStmt = compilationUnit.statements[index + 1];
+                                if (nextStmt === null || nextStmt === void 0 ? void 0 : nextStmt.element) {
+                                    nextStatementPrefix = jsImport.prefix;
+                                }
+                            }
+                            // Remove the entire import
+                            return undefined;
+                        }
+                        return Object.assign(Object.assign({}, stmt), { element: result });
+                    }
+                    // Handle CommonJS require statements
+                    // Note: const fs = require() comes as J.VariableDeclarations, not ScopedVariableDeclarations
+                    if ((statement === null || statement === void 0 ? void 0 : statement.kind) === java_1.J.Kind.VariableDeclarations) {
+                        const varDecl = statement;
+                        const result = yield this.processRequireFromVarDecls(varDecl, usedIdentifiers, p);
+                        if (result === undefined) {
+                            // Store the prefix for the next statement to avoid leaving blank lines
+                            if (index < compilationUnit.statements.length - 1) {
+                                const nextStmt = compilationUnit.statements[index + 1];
+                                if (nextStmt === null || nextStmt === void 0 ? void 0 : nextStmt.element) {
+                                    nextStatementPrefix = varDecl.prefix;
+                                }
+                            }
+                            // Remove the entire require statement
+                            return undefined;
+                        }
+                        return Object.assign(Object.assign({}, stmt), { element: result });
+                    }
+                    // Apply stored prefix if this statement follows a removed import
+                    if (nextStatementPrefix && statement) {
+                        const updatedStatement = yield this.visit(statement, p);
+                        if (updatedStatement) {
+                            updatedStatement.prefix = nextStatementPrefix;
+                            nextStatementPrefix = undefined;
+                            return Object.assign(Object.assign({}, stmt), { element: updatedStatement });
+                        }
+                    }
+                    return stmt;
+                }));
+                // Filter out undefined (removed) statements
+                draft.statements = draft.statements.filter(s => s !== undefined);
+                draft.eof = yield this.visitSpace(compilationUnit.eof, p);
+            }));
+        });
+    }
+    processImport(jsImport, usedIdentifiers, usedTypes, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if this import is from the target module
+            if (!this.isTargetModule(jsImport)) {
+                return jsImport;
+            }
+            const importClause = jsImport.importClause;
+            if (!importClause) {
+                // Side-effect import like: import 'module'
+                if (this.member === '*') {
+                    return undefined; // Remove the entire import
+                }
+                return jsImport;
+            }
+            // Process default import
+            if (importClause.name) {
+                const defaultName = importClause.name.element;
+                if (defaultName && defaultName.kind === java_1.J.Kind.Identifier) {
+                    const identifier = defaultName;
+                    const name = identifier.simpleName;
+                    if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes)) {
+                        // If there are no named imports, remove the entire import
+                        if (!importClause.namedBindings) {
+                            return undefined;
+                        }
+                        // Otherwise, just remove the default import
+                        return this.updateImportClause(jsImport, importClause, draft => {
+                            draft.name = undefined;
+                        }, p);
+                    }
+                }
+            }
+            // Process named imports
+            if (importClause.namedBindings) {
+                const namedBindings = importClause.namedBindings;
+                // Handle namespace import: import * as X from 'module'
+                if (namedBindings.kind === java_1.J.Kind.Identifier) {
+                    const identifier = namedBindings;
+                    const name = identifier.simpleName;
+                    if (this.shouldRemoveImport(name, usedIdentifiers, usedTypes)) {
+                        // If there's no default import, remove the entire import
+                        if (!importClause.name) {
+                            return undefined;
+                        }
+                        // Otherwise, just remove the namespace import
+                        return this.updateImportClause(jsImport, importClause, draft => {
+                            draft.namedBindings = undefined;
+                        }, p);
+                    }
+                }
+                else if (namedBindings.kind === tree_1.JS.Kind.Alias) {
+                    // Handle import * as X from 'module' - represented as Alias with propertyName = "*"
+                    const alias = namedBindings;
+                    const aliasName = alias.alias.simpleName;
+                    if (this.shouldRemoveImport(aliasName, usedIdentifiers, usedTypes)) {
+                        // If there's no default import, remove the entire import
+                        if (!importClause.name) {
+                            return undefined;
+                        }
+                        // Otherwise, just remove the namespace import
+                        return this.updateImportClause(jsImport, importClause, draft => {
+                            draft.namedBindings = undefined;
+                        }, p);
+                    }
+                }
+                // Handle named imports: import { a, b } from 'module'
+                if (namedBindings.kind === tree_1.JS.Kind.NamedImports) {
+                    const namedImports = namedBindings;
+                    const updatedImports = yield this.processNamedImports(namedImports, usedIdentifiers, usedTypes, p);
+                    if (updatedImports === undefined) {
+                        // All named imports were removed
+                        if (!importClause.name) {
+                            // No default import either, remove the entire import
+                            return undefined;
+                        }
+                        // Keep the import with just the default import
+                        return this.updateImportClause(jsImport, importClause, draft => {
+                            draft.namedBindings = undefined;
+                        }, p);
+                    }
+                    else if (updatedImports !== namedImports) {
+                        // Some named imports were removed
+                        return this.updateImportClause(jsImport, importClause, draft => {
+                            draft.namedBindings = updatedImports;
+                        }, p);
+                    }
+                }
+            }
+            return jsImport;
+        });
+    }
+    processNamedImports(namedImports, usedIdentifiers, usedTypes, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filtered, allRemoved } = yield this.filterElementsWithPrefixPreservation(namedImports.elements.elements, (elem) => {
+                if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
+                    const importName = this.getImportName(elem);
+                    return !this.shouldRemoveImport(importName, usedIdentifiers, usedTypes);
+                }
+                return true; // Keep non-ImportSpecifier elements
+            }, (elem, prefix) => __awaiter(this, void 0, void 0, function* () {
+                if (elem.kind === tree_1.JS.Kind.ImportSpecifier) {
+                    return this.produceJavaScript(elem, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                        draft.prefix = prefix;
+                    }));
+                }
+                return elem;
+            }), p);
+            if (allRemoved) {
+                return undefined;
+            }
+            if (filtered.length === namedImports.elements.elements.length) {
+                return namedImports; // No changes
+            }
+            // Create updated named imports with filtered elements
+            return this.produceJavaScript(namedImports, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                draft.elements = Object.assign(Object.assign({}, namedImports.elements), { elements: filtered });
+            }));
+        });
+    }
+    processRequireFromVarDecls(varDecls, usedIdentifiers, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Check if this is a require() call
+            if (varDecls.variables.length !== 1) {
+                return varDecls;
+            }
+            const namedVar = varDecls.variables[0].element;
+            if (!namedVar) {
+                return varDecls;
+            }
+            const initializer = (_a = namedVar.initializer) === null || _a === void 0 ? void 0 : _a.element;
+            if (!initializer || initializer.kind !== java_1.J.Kind.MethodInvocation) {
+                return varDecls;
+            }
+            const methodInv = initializer;
+            if (((_b = methodInv.name) === null || _b === void 0 ? void 0 : _b.kind) !== java_1.J.Kind.Identifier || methodInv.name.simpleName !== 'require') {
+                return varDecls;
+            }
+            // This is a require() statement
+            const pattern = namedVar.name;
+            if (!pattern) {
+                return varDecls;
+            }
+            // Handle: const fs = require('fs')
+            if (pattern.kind === java_1.J.Kind.Identifier) {
+                const varName = pattern.simpleName;
+                if (this.shouldRemoveImport(varName, usedIdentifiers, new Set())) {
+                    return undefined; // Remove the entire require statement
+                }
+            }
+            // Handle: const { readFile } = require('fs')
+            if (pattern.kind === tree_1.JS.Kind.ObjectBindingPattern && this.member !== undefined) {
+                const objectPattern = pattern;
+                const updatedPattern = yield this.processObjectBindingPattern(objectPattern, usedIdentifiers, p);
+                if (updatedPattern === undefined) {
+                    return undefined; // Remove entire require
+                }
+                else if (updatedPattern !== objectPattern) {
+                    // Update with filtered bindings
+                    return this.produceJava(varDecls, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                        const updatedNamedVar = yield this.produceJava(namedVar, p, (namedDraft) => __awaiter(this, void 0, void 0, function* () {
+                            namedDraft.name = updatedPattern;
+                        }));
+                        draft.variables = [Object.assign(Object.assign({}, varDecls.variables[0]), { element: updatedNamedVar })];
+                    }));
+                }
+            }
+            return varDecls;
+        });
+    }
+    processObjectBindingPattern(pattern, usedIdentifiers, p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { filtered, allRemoved } = yield this.filterElementsWithPrefixPreservation(pattern.bindings.elements, (elem) => {
+                if (elem.kind === tree_1.JS.Kind.BindingElement) {
+                    const name = this.getBindingElementName(elem);
+                    return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
+                }
+                else if (elem.kind === java_1.J.Kind.Identifier) {
+                    const name = elem.simpleName;
+                    return !this.shouldRemoveImport(name, usedIdentifiers, new Set());
+                }
+                return true; // Keep other element types
+            }, (elem, prefix) => __awaiter(this, void 0, void 0, function* () {
+                if (elem.kind === java_1.J.Kind.Identifier) {
+                    return this.produceJava(elem, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                        draft.prefix = prefix;
+                    }));
+                }
+                else if (elem.kind === tree_1.JS.Kind.BindingElement) {
+                    return this.produceJavaScript(elem, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                        draft.prefix = prefix;
+                    }));
+                }
+                return elem;
+            }), p);
+            if (allRemoved) {
+                return undefined;
+            }
+            if (filtered.length === pattern.bindings.elements.length) {
+                return pattern;
+            }
+            return this.produceJavaScript(pattern, p, (draft) => __awaiter(this, void 0, void 0, function* () {
+                draft.bindings = Object.assign(Object.assign({}, pattern.bindings), { elements: filtered });
+            }));
+        });
+    }
+    getImportName(specifier) {
+        const spec = specifier.specifier;
+        if ((spec === null || spec === void 0 ? void 0 : spec.kind) === tree_1.JS.Kind.Alias) {
+            // Handle aliased import: import { foo as bar }
+            const alias = spec;
+            const propertyName = alias.propertyName.element;
+            if ((propertyName === null || propertyName === void 0 ? void 0 : propertyName.kind) === java_1.J.Kind.Identifier) {
+                return propertyName.simpleName;
+            }
+        }
+        else if ((spec === null || spec === void 0 ? void 0 : spec.kind) === java_1.J.Kind.Identifier) {
+            // Handle regular import: import { foo }
+            return spec.simpleName;
+        }
+        return '';
+    }
+    getBindingElementName(bindingElement) {
+        const name = bindingElement.name;
+        if ((name === null || name === void 0 ? void 0 : name.kind) === java_1.J.Kind.Identifier) {
+            return name.simpleName;
+        }
+        return '';
+    }
+    shouldRemoveImport(name, usedIdentifiers, usedTypes) {
+        // If member is specified, we're removing a specific member from a 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;
+            }
+        }
+        // Check if it's used
+        return !(usedIdentifiers.has(name) || usedTypes.has(name));
+    }
+    isTargetModule(jsImport) {
+        var _a, _b;
+        // If member is specified, we're looking for imports from a specific module
+        if (this.member !== undefined) {
+            const moduleSpecifier = (_a = jsImport.moduleSpecifier) === null || _a === void 0 ? void 0 : _a.element;
+            if (!moduleSpecifier || moduleSpecifier.kind !== java_1.J.Kind.Literal) {
+                return false;
+            }
+            const literal = moduleSpecifier;
+            const moduleName = (_b = literal.value) === null || _b === void 0 ? void 0 : _b.toString().replace(/['"`]/g, '');
+            // Match the module name
+            return moduleName === this.target;
+        }
+        // If no member specified, we process all imports to check their names
+        return true;
+    }
+    /**
+     * Helper to traverse parameters from various node types
+     */
+    traverseParameters(params, usedIdentifiers, usedTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params || typeof params !== 'object')
+                return;
+            if (Array.isArray(params)) {
+                for (const p of params) {
+                    yield this.collectUsedIdentifiers(p, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (params.elements) {
+                for (const p of params.elements) {
+                    if (p.element) {
+                        yield this.collectUsedIdentifiers(p.element, usedIdentifiers, usedTypes);
+                    }
+                }
+            }
+            else if (params.parameters) {
+                for (const p of params.parameters) {
+                    const elem = p.element || p;
+                    yield this.collectUsedIdentifiers(elem, usedIdentifiers, usedTypes);
+                }
+            }
+        });
+    }
+    /**
+     * Helper to traverse statements from various node types
+     */
+    traverseStatements(statements, usedIdentifiers, usedTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!statements)
+                return;
+            if (Array.isArray(statements)) {
+                for (const stmt of statements) {
+                    const element = stmt.element || stmt;
+                    if (element) {
+                        yield this.collectUsedIdentifiers(element, usedIdentifiers, usedTypes);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Helper to check for type expressions and collect type usage
+     */
+    checkTypeExpression(node, usedTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (node.typeExpression) {
+                yield this.collectTypeUsage(node.typeExpression, usedTypes);
+            }
+        });
+    }
+    collectUsedIdentifiers(node, usedIdentifiers, usedTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            if (node.kind === java_1.J.Kind.Identifier) {
+                const identifier = node;
+                usedIdentifiers.add(identifier.simpleName);
+            }
+            else if (node.kind === java_1.J.Kind.MethodInvocation) {
+                const methodInv = node;
+                // Check if this is a member access pattern like fs.readFileSync
+                if (((_b = (_a = methodInv.select) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.kind) === java_1.J.Kind.FieldAccess) {
+                    const fieldAccess = methodInv.select.element;
+                    if (((_c = fieldAccess.target) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Identifier) {
+                        usedIdentifiers.add(fieldAccess.target.simpleName);
+                    }
+                }
+                else if (((_e = (_d = methodInv.select) === null || _d === void 0 ? void 0 : _d.element) === null || _e === void 0 ? void 0 : _e.kind) === java_1.J.Kind.Identifier) {
+                    // Direct identifier like fs in fs.method() - though this is rare
+                    usedIdentifiers.add(methodInv.select.element.simpleName);
+                }
+                // Collect method name
+                if (methodInv.name && methodInv.name.kind === java_1.J.Kind.Identifier) {
+                    usedIdentifiers.add(methodInv.name.simpleName);
+                }
+                // Recursively check arguments
+                if (methodInv.arguments) {
+                    for (const arg of methodInv.arguments.elements) {
+                        if (arg.element) {
+                            yield this.collectUsedIdentifiers(arg.element, usedIdentifiers, usedTypes);
+                        }
+                    }
+                }
+                // Check select (object being called on)
+                if ((_f = methodInv.select) === null || _f === void 0 ? void 0 : _f.element) {
+                    yield this.collectUsedIdentifiers(methodInv.select.element, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.kind === java_1.J.Kind.MemberReference) {
+                const memberRef = node;
+                if (memberRef.containing && ((_g = memberRef.containing.element) === null || _g === void 0 ? void 0 : _g.kind) === java_1.J.Kind.Identifier) {
+                    usedIdentifiers.add(memberRef.containing.element.simpleName);
+                }
+            }
+            else if (node.kind === java_1.J.Kind.FieldAccess) {
+                // Handle field access like fs.readFileSync
+                const fieldAccess = node;
+                if (((_h = fieldAccess.target) === null || _h === void 0 ? void 0 : _h.kind) === java_1.J.Kind.Identifier) {
+                    usedIdentifiers.add(fieldAccess.target.simpleName);
+                }
+                // Recursively check the target
+                if (fieldAccess.target) {
+                    yield this.collectUsedIdentifiers(fieldAccess.target, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.kind === tree_1.JS.Kind.CompilationUnit) {
+                const cu = node;
+                for (const stmt of cu.statements) {
+                    if (stmt.element && stmt.element.kind !== tree_1.JS.Kind.Import) {
+                        // Skip require() statements at the top level
+                        if (stmt.element.kind === java_1.J.Kind.VariableDeclarations) {
+                            const varDecls = stmt.element;
+                            // Check if this is a require() statement
+                            let isRequire = false;
+                            for (const v of varDecls.variables) {
+                                const namedVar = v.element;
+                                if (((_k = (_j = namedVar === null || namedVar === void 0 ? void 0 : namedVar.initializer) === null || _j === void 0 ? void 0 : _j.element) === null || _k === void 0 ? void 0 : _k.kind) === java_1.J.Kind.MethodInvocation) {
+                                    const methodInv = namedVar.initializer.element;
+                                    if (((_l = methodInv.name) === null || _l === void 0 ? void 0 : _l.kind) === java_1.J.Kind.Identifier &&
+                                        methodInv.name.simpleName === 'require') {
+                                        isRequire = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!isRequire) {
+                                // Not a require statement, process normally
+                                yield this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
+                            }
+                        }
+                        else if (stmt.element.kind !== tree_1.JS.Kind.ScopedVariableDeclarations) {
+                            // Process other non-import, non-require statements normally
+                            yield this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
+                        }
+                    }
+                }
+            }
+            else if (node.kind === java_1.J.Kind.Return) {
+                // Handle return statements
+                const returnStmt = node;
+                if (returnStmt.expression) {
+                    yield this.collectUsedIdentifiers(returnStmt.expression, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.kind === java_1.J.Kind.Block) {
+                const block = node;
+                for (const stmt of block.statements) {
+                    if (stmt.element) {
+                        yield this.collectUsedIdentifiers(stmt.element, usedIdentifiers, usedTypes);
+                    }
+                }
+            }
+            else if (node.kind === java_1.J.Kind.MethodDeclaration) {
+                const method = node;
+                // 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) {
+                            yield this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
+                        }
+                    }
+                }
+                // Check body
+                if (method.body) {
+                    yield this.collectUsedIdentifiers(method.body, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.typeExpression) {
+                // Handle nodes with type expressions (parameters, variables, etc.)
+                yield this.checkTypeExpression(node, usedTypes);
+                // Continue traversing other parts
+                if (node.name) {
+                    yield this.collectUsedIdentifiers(node.name, usedIdentifiers, usedTypes);
+                }
+                if (node.initializer) {
+                    yield this.collectUsedIdentifiers(node.initializer, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.kind === tree_1.JS.Kind.ArrowFunction || node.kind === java_1.J.Kind.Lambda) {
+                // Handle arrow functions and lambdas
+                const func = node;
+                if (func.parameters) {
+                    yield this.collectUsedIdentifiers(func.parameters, usedIdentifiers, usedTypes);
+                }
+                if (func.lambda) {
+                    yield this.collectUsedIdentifiers(func.lambda, usedIdentifiers, usedTypes);
+                }
+                if (func.body) {
+                    yield this.collectUsedIdentifiers(func.body, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.kind === java_1.J.Kind.Lambda) {
+                const lambda = node;
+                if ((_m = lambda.parameters) === null || _m === void 0 ? void 0 : _m.parameters) {
+                    for (const param of lambda.parameters.parameters) {
+                        if (param.element) {
+                            yield this.collectUsedIdentifiers(param.element, usedIdentifiers, usedTypes);
+                        }
+                    }
+                }
+                if (lambda.body) {
+                    yield this.collectUsedIdentifiers(lambda.body, usedIdentifiers, usedTypes);
+                }
+            }
+            else if (node.kind === java_1.J.Kind.VariableDeclarations) {
+                const varDecls = node;
+                // Check the type expression on the VariableDeclarations itself
+                yield this.checkTypeExpression(varDecls, usedTypes);
+                for (const v of varDecls.variables) {
+                    const namedVar = v.element;
+                    if (namedVar) {
+                        // Check type annotation on the variable
+                        yield this.checkTypeExpression(namedVar, usedTypes);
+                        // Check the variable name
+                        if (namedVar.name) {
+                            yield this.collectUsedIdentifiers(namedVar.name, usedIdentifiers, usedTypes);
+                        }
+                        // Check the initializer
+                        if (namedVar.initializer && namedVar.initializer.element) {
+                            yield this.collectUsedIdentifiers(namedVar.initializer.element, usedIdentifiers, usedTypes);
+                        }
+                    }
+                }
+            }
+            else if (node.statements) {
+                // Generic handler for nodes with statements
+                yield this.traverseStatements(node.statements, usedIdentifiers, usedTypes);
+            }
+            else if (node.body) {
+                // Generic handler for nodes with body
+                yield this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
+            }
+            else if (node.parameters) {
+                // Handle anything with parameters (functions, methods, etc.)
+                yield this.traverseParameters(node.parameters, usedIdentifiers, usedTypes);
+                // Continue with the body if it exists
+                if (node.body) {
+                    yield this.collectUsedIdentifiers(node.body, usedIdentifiers, usedTypes);
+                }
+            }
+        });
+    }
+    collectTypeUsage(typeExpr, usedTypes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeExpr.kind === java_1.J.Kind.Identifier) {
+                usedTypes.add(typeExpr.simpleName);
+            }
+            else if (typeExpr.kind === java_1.J.Kind.ParameterizedType) {
+                const paramType = typeExpr;
+                // In TypeScript AST, ParameterizedType might have a different structure
+                // We'll need to handle the type parameters appropriately
+                if (paramType.typeParameters) {
+                    for (const typeParam of paramType.typeParameters.elements) {
+                        if (typeParam.element) {
+                            yield this.collectTypeUsage(typeParam.element, usedTypes);
+                        }
+                    }
+                }
+            }
+            else if (typeExpr.kind === tree_1.JS.Kind.TypeTreeExpression) {
+                // Handle TypeTreeExpression which wraps type identifiers
+                const typeTree = typeExpr;
+                if (typeTree.expression) {
+                    yield this.collectTypeUsage(typeTree.expression, usedTypes);
+                }
+            }
+            else if (typeExpr.kind === tree_1.JS.Kind.TypeInfo) {
+                // Handle TypeInfo which contains type identifiers
+                const typeInfo = typeExpr;
+                if (typeInfo.typeIdentifier) {
+                    yield this.collectTypeUsage(typeInfo.typeIdentifier, usedTypes);
+                }
+            }
+            else if (typeExpr.expression) {
+                // Generic handler for nodes with expression property
+                yield this.collectTypeUsage(typeExpr.expression, usedTypes);
+            }
+            else if (typeExpr.typeIdentifier) {
+                // Generic handler for nodes with typeIdentifier property
+                yield this.collectTypeUsage(typeExpr.typeIdentifier, usedTypes);
+            }
+            // Add more type expression handlers as needed
+        });
+    }
+}
+exports.RemoveImport = RemoveImport;
+//# sourceMappingURL=remove-import.js.map