From 37b977289c3219bfcb1c28a3ee54e0e4cf790e2e Mon Sep 17 00:00:00 2001 From: ketan5050 Date: Sat, 21 Nov 2026 23:49:05 -0400 Subject: [PATCH 1/6] Rename Worder.dumb_finder to fallback_finder The old name is vague and unprofessional. The field holds a plain finder over the original source used when the offset falls inside an ignored region. Rename both the definition and the single use in _context_call. No behavior change. --- rope/base/worder.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rope/base/worder.py b/rope/base/worder.py index 97ea8d405..11261ba9f 100644 --- a/rope/base/worder.py +++ b/rope/base/worder.py @@ -33,7 +33,7 @@ def __init__(self, code, handle_ignores=False): def _init_ignores(self): ignores = rope.base.simplify.ignored_regions(self.code) - self.dumb_finder = _RealFinder(self.code, self.code) + self.fallback_finder = _RealFinder(self.code, self.code) self.starts = [ignored[0] for ignored in ignores] self.ends = [ignored[1] for ignored in ignores] @@ -43,7 +43,7 @@ def _context_call(self, name, offset): self._init_ignores() start = bisect.bisect(self.starts, offset) if start > 0 and offset < self.ends[start - 1]: - return getattr(self.dumb_finder, name)(offset) + return getattr(self.fallback_finder, name)(offset) return getattr(self.code_finder, name)(offset) def get_primary_at(self, offset): From acdee4179d3a69650d7c5699b77dbe99e48b5665 Mon Sep 17 00:00:00 2001 From: ketan5050 Date: Sat, 21 Nov 2026 23:50:09 -0400 Subject: [PATCH 2/6] Replace conditional with dispatch table in get_type_ast Replace the repeated isinstance if-chain with a small type map iterated with isinstance. Same behavior, adding a new node kind now means adding one table entry instead of another branch. --- rope/contrib/autoimport/parse.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/rope/contrib/autoimport/parse.py b/rope/contrib/autoimport/parse.py index d468fe90b..1520dca63 100644 --- a/rope/contrib/autoimport/parse.py +++ b/rope/contrib/autoimport/parse.py @@ -26,14 +26,18 @@ logger = logging.getLogger(__name__) +_NODE_TYPE_MAP = ( + (ast.ClassDef, NameType.Class), + (ast.FunctionDef, NameType.Function), + (ast.Assign, NameType.Variable), +) + + def get_type_ast(node: ast.AST) -> NameType: """Get the lsp type of a node.""" - if isinstance(node, ast.ClassDef): - return NameType.Class - if isinstance(node, ast.FunctionDef): - return NameType.Function - if isinstance(node, ast.Assign): - return NameType.Variable + for node_type, name_type in _NODE_TYPE_MAP: + if isinstance(node, node_type): + return name_type return NameType.Variable # default value From 87339892e9db6df37f4fa7d3051e3eee6da3699d Mon Sep 17 00:00:00 2001 From: ketan5050 Date: Sat, 21 Nov 2026 23:51:18 -0400 Subject: [PATCH 3/6] Extract _names_from_importfrom from get_names_from_file Move the relative from-import loop out of the main child-node loop into its own generator. get_names_from_file keeps Assign and def/class handling; import handling is now testable in isolation. No behavior change. --- rope/contrib/autoimport/parse.py | 36 +++++++++++++++++++------------- 1 file changed, 21 insertions(+), 15 deletions(-) diff --git a/rope/contrib/autoimport/parse.py b/rope/contrib/autoimport/parse.py index 1520dca63..9f025399e 100644 --- a/rope/contrib/autoimport/parse.py +++ b/rope/contrib/autoimport/parse.py @@ -73,21 +73,27 @@ def get_names_from_file( get_type_ast(node), ) elif process_imports and isinstance(node, ast.ImportFrom): - # When we process imports, we want to include names in it's own package. - if node.level == 0: - continue - if not node.module or package_name is node.module.split(".")[0]: - continue - for name in node.names: - if isinstance(name, ast.alias): - if name.asname: - real_name = name.asname - else: - real_name = name.name - else: - real_name = name - if underlined or not real_name.startswith("_"): - yield PartialName(real_name, get_type_ast(node)) + yield from _names_from_importfrom(node, package_name, underlined) + + +def _names_from_importfrom( + node: ast.ImportFrom, + package_name: str, + underlined: bool, +) -> Generator[PartialName, None, None]: + """Yield re-exported names from a relative from-import.""" + # When we process imports, we want to include names in it's own package. + if node.level == 0: + return + if not node.module or package_name is node.module.split(".")[0]: + return + for name in node.names: + if isinstance(name, ast.alias): + real_name = name.asname if name.asname else name.name + else: + real_name = name + if underlined or not real_name.startswith("_"): + yield PartialName(real_name, get_type_ast(node)) def get_type_object(imported_object) -> NameType: From a71f5fee3f5b78d17057d6bc2eb367b8faf77a35 Mon Sep 17 00:00:00 2001 From: ketan5050 Date: Sat, 21 Nov 2026 23:51:44 -0400 Subject: [PATCH 4/6] Introduce explaining variables in _get_all_star_list Name the repeated isinstance checks as is_str_constant, is_name_ref and is_str_assignment so the star-list branches read as intent instead of type-test soup. No behavior change. --- rope/refactor/importutils/module_imports.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/rope/refactor/importutils/module_imports.py b/rope/refactor/importutils/module_imports.py index f35b22521..faa415476 100644 --- a/rope/refactor/importutils/module_imports.py +++ b/rope/refactor/importutils/module_imports.py @@ -69,22 +69,23 @@ def _resolve_name( elif isinstance(el, ast.Starred): assignments.append(el.value) else: - if isinstance(el, ast.Constant) and isinstance(el.value, str): + is_str_constant = isinstance(el, ast.Constant) and isinstance( + el.value, str + ) + is_name_ref = isinstance(el, ast.Name) + if is_str_constant: result.add(el.value) - elif isinstance(el, ast.Name): + elif is_name_ref: try: name = pymodule.get_attribute(el.id) except exceptions.AttributeNotFoundError: continue else: for av in _resolve_name(name): - if isinstance( - av.ast_node, - ast.Constant, - ) and isinstance( - av.ast_node.value, - str, - ): + is_str_assignment = isinstance( + av.ast_node, ast.Constant + ) and isinstance(av.ast_node.value, str) + if is_str_assignment: result.add(av.ast_node.value) elif isinstance(assignment, ast.Name): try: From 39570120d408aaaf903a271a8cdb7948e7063776 Mon Sep 17 00:00:00 2001 From: ketan5050 Date: Sat, 21 Nov 2026 23:52:20 -0400 Subject: [PATCH 5/6] Move star-name resolver to module level Move the nested _resolve_name out of ModuleImports._get_all_star_list as _resolve_assigned_names. It never used self; nesting hid it from reuse and tests. Update the three call sites. No behavior change. --- rope/refactor/importutils/module_imports.py | 35 +++++++++++---------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/rope/refactor/importutils/module_imports.py b/rope/refactor/importutils/module_imports.py index faa415476..fb61cf8ce 100644 --- a/rope/refactor/importutils/module_imports.py +++ b/rope/refactor/importutils/module_imports.py @@ -4,6 +4,21 @@ from rope.refactor.importutils import actions, importinfo +def _resolve_assigned_names( + name: Union[pynamesdef.AssignedName, pynames.ImportedName], +) -> List: + """Follow import aliases to the underlying assigned names.""" + while isinstance(name, pynames.ImportedName): + try: + name = name.imported_module.get_object().get_attribute( + name.imported_name, + ) + except exceptions.AttributeNotFoundError: + return [] + assert isinstance(name, pynamesdef.AssignedName) + return name.assignments + + class ModuleImports: def __init__(self, project, pymodule, import_filter=None): self.project = project @@ -30,19 +45,6 @@ def _get_unbound_names(self, defined_pyobject): return visitor.unbound def _get_all_star_list(self, pymodule): - def _resolve_name( - name: Union[pynamesdef.AssignedName, pynames.ImportedName], - ) -> List: - while isinstance(name, pynames.ImportedName): - try: - name = name.imported_module.get_object().get_attribute( - name.imported_name, - ) - except exceptions.AttributeNotFoundError: - return [] - assert isinstance(name, pynamesdef.AssignedName) - return name.assignments - result = set() try: all_star_list = pymodule.get_attribute("__all__") @@ -50,7 +52,7 @@ def _resolve_name( return result assignments = [ - assignment.ast_node for assignment in _resolve_name(all_star_list) + assignment.ast_node for assignment in _resolve_assigned_names(all_star_list) ] # FIXME: Need a better way to recursively infer possible values. @@ -81,7 +83,7 @@ def _resolve_name( except exceptions.AttributeNotFoundError: continue else: - for av in _resolve_name(name): + for av in _resolve_assigned_names(name): is_str_assignment = isinstance( av.ast_node, ast.Constant ) and isinstance(av.ast_node.value, str) @@ -94,7 +96,8 @@ def _resolve_name( continue else: assignments.extend( - assignment.ast_node for assignment in _resolve_name(name) + assignment.ast_node + for assignment in _resolve_assigned_names(name) ) elif isinstance(assignment, ast.BinOp): assignments.append(assignment.left) From 3d1e1f933f691c97932b998b7c44e68df6cdc02e Mon Sep 17 00:00:00 2001 From: ketan5050 Date: Sat, 21 Nov 2026 23:54:22 -0400 Subject: [PATCH 6/6] Extract _StarListCollector from ModuleImports Move the pending-assignments stack and collected names out of _get_all_star_list into a small helper class with has_pending, next_assignment, defer, defer_many and add. The method keeps the traversal logic; state lives in the new class. No behavior change. --- rope/refactor/importutils/module_imports.py | 48 +++++++++++++++------ 1 file changed, 35 insertions(+), 13 deletions(-) diff --git a/rope/refactor/importutils/module_imports.py b/rope/refactor/importutils/module_imports.py index fb61cf8ce..780e3c80a 100644 --- a/rope/refactor/importutils/module_imports.py +++ b/rope/refactor/importutils/module_imports.py @@ -19,6 +19,29 @@ def _resolve_assigned_names( return name.assignments +class _StarListCollector: + """Hold pending __all__ assignments and collected star names.""" + + def __init__(self, initial_assignments): + self.pending = list(initial_assignments) + self.names = set() + + def has_pending(self): + return bool(self.pending) + + def next_assignment(self): + return self.pending.pop() + + def defer(self, assignment): + self.pending.append(assignment) + + def defer_many(self, assignments): + self.pending.extend(assignments) + + def add(self, name): + self.names.add(name) + + class ModuleImports: def __init__(self, project, pymodule, import_filter=None): self.project = project @@ -45,22 +68,21 @@ def _get_unbound_names(self, defined_pyobject): return visitor.unbound def _get_all_star_list(self, pymodule): - result = set() try: all_star_list = pymodule.get_attribute("__all__") except exceptions.AttributeNotFoundError: - return result + return set() - assignments = [ + collector = _StarListCollector( assignment.ast_node for assignment in _resolve_assigned_names(all_star_list) - ] + ) # FIXME: Need a better way to recursively infer possible values. # Currently pyobjects can recursively infer type, but not values. # Do a very basic 1-level value inference - while assignments: - assignment = assignments.pop() + while collector.has_pending(): + assignment = collector.next_assignment() if isinstance(assignment, ast.List): stack = list(assignment.elts) while stack: @@ -69,14 +91,14 @@ def _get_all_star_list(self, pymodule): stack.append(el.body) stack.append(el.orelse) elif isinstance(el, ast.Starred): - assignments.append(el.value) + collector.defer(el.value) else: is_str_constant = isinstance(el, ast.Constant) and isinstance( el.value, str ) is_name_ref = isinstance(el, ast.Name) if is_str_constant: - result.add(el.value) + collector.add(el.value) elif is_name_ref: try: name = pymodule.get_attribute(el.id) @@ -88,21 +110,21 @@ def _get_all_star_list(self, pymodule): av.ast_node, ast.Constant ) and isinstance(av.ast_node.value, str) if is_str_assignment: - result.add(av.ast_node.value) + collector.add(av.ast_node.value) elif isinstance(assignment, ast.Name): try: name = pymodule.get_attribute(assignment.id) except exceptions.AttributeNotFoundError: continue else: - assignments.extend( + collector.defer_many( assignment.ast_node for assignment in _resolve_assigned_names(name) ) elif isinstance(assignment, ast.BinOp): - assignments.append(assignment.left) - assignments.append(assignment.right) - return result + collector.defer(assignment.left) + collector.defer(assignment.right) + return collector.names def remove_unused_imports(self): can_select = _OneTimeSelector(