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): diff --git a/rope/contrib/autoimport/parse.py b/rope/contrib/autoimport/parse.py index d468fe90b..9f025399e 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 @@ -69,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: diff --git a/rope/refactor/importutils/module_imports.py b/rope/refactor/importutils/module_imports.py index f35b22521..780e3c80a 100644 --- a/rope/refactor/importutils/module_imports.py +++ b/rope/refactor/importutils/module_imports.py @@ -4,6 +4,44 @@ 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 _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 @@ -30,35 +68,21 @@ 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__") except exceptions.AttributeNotFoundError: - return result + return set() - assignments = [ - assignment.ast_node for assignment in _resolve_name(all_star_list) - ] + 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: @@ -67,38 +91,40 @@ def _resolve_name( stack.append(el.body) stack.append(el.orelse) elif isinstance(el, ast.Starred): - assignments.append(el.value) + collector.defer(el.value) else: - if isinstance(el, ast.Constant) and isinstance(el.value, str): - result.add(el.value) - elif isinstance(el, ast.Name): + is_str_constant = isinstance(el, ast.Constant) and isinstance( + el.value, str + ) + is_name_ref = isinstance(el, ast.Name) + if is_str_constant: + collector.add(el.value) + 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, - ): - result.add(av.ast_node.value) + for av in _resolve_assigned_names(name): + is_str_assignment = isinstance( + av.ast_node, ast.Constant + ) and isinstance(av.ast_node.value, str) + if is_str_assignment: + 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( - assignment.ast_node for assignment in _resolve_name(name) + 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(