diff --git a/jedi/api/__init__.py b/jedi/api/__init__.py index a4ec5363..d2a6e4b6 100644 --- a/jedi/api/__init__.py +++ b/jedi/api/__init__.py @@ -505,23 +505,23 @@ class Script(object): quite hard to do for Jedi, if it is too complicated, Jedi will stop searching. - :param include_builtins: Default ``True``. If ``False`` checks if a reference + :param include_builtins: Default ``True``. If ``False``, checks if a reference is a builtin (e.g. ``sys``) and in that case does not return it. - :param all_scopes: Default ``True``. If ``False`` include references in + :param scope: Default ``'project'``. If ``'file'``, include references in the current module only. :rtype: list of :class:`.Name` """ - def _references(include_builtins=True, all_scopes=True): + def _references(include_builtins=True, scope='project'): tree_name = self._module_node.get_name_of_position((line, column)) if tree_name is None: # Must be syntax return [] - names = find_references(self._get_module_context(), tree_name, all_scopes) + names = find_references(self._get_module_context(), tree_name, scope == 'file') definitions = [classes.Name(self._inference_state, n) for n in names] - if not (include_builtins and all_scopes): + if not include_builtins or scope == 'file': definitions = [d for d in definitions if not d.in_builtin_module()] return helpers.sorted_definitions(definitions) return _references(**kwargs) diff --git a/jedi/inference/names.py b/jedi/inference/names.py index 6a75504a..ccf42d4c 100644 --- a/jedi/inference/names.py +++ b/jedi/inference/names.py @@ -138,7 +138,7 @@ class AbstractTreeName(AbstractNameDefinition): return self.parent_context.get_value() # Might be None return None - def goto(self, all_scopes=True): + def goto(self): context = self.parent_context name = self.tree_name definition = name.get_definition(import_name_always=True) @@ -150,13 +150,13 @@ class AbstractTreeName(AbstractNameDefinition): is_simple_name = name.parent.type not in ('power', 'trailer') if is_simple_name: return [self] - elif all_scopes and type_ in ('import_from', 'import_name'): + elif type_ in ('import_from', 'import_name'): from jedi.inference.imports import goto_import module_names = goto_import(context, name) return module_names else: return [self] - elif all_scopes: + else: from jedi.inference.imports import follow_error_node_imports_if_possible values = follow_error_node_imports_if_possible(context, name) if values is not None: @@ -166,8 +166,6 @@ class AbstractTreeName(AbstractNameDefinition): node_type = par.type if node_type == 'argument' and par.children[1] == '=' and par.children[0] == name: # Named param goto. - if not all_scopes: - return [self] trailer = par.parent if trailer.type == 'arglist': trailer = trailer.parent @@ -202,8 +200,6 @@ class AbstractTreeName(AbstractNameDefinition): ) if node_type == 'trailer' and par.children[0] == '.': - if not all_scopes: - return [self] values = infer_call_of_leaf(context, name, cut_own_trailer=True) return values.goto(name, name_context=context) else: @@ -502,8 +498,8 @@ class _ActualTreeParamName(BaseTreeParamName): class AnonymousParamName(_ActualTreeParamName): @plugin_manager.decorate(name='goto_anonymous_param') - def goto(self, **kwargs): - return super(AnonymousParamName, self).goto(**kwargs) + def goto(self): + return super(AnonymousParamName, self).goto() @plugin_manager.decorate(name='infer_anonymous_param') def infer(self): diff --git a/jedi/inference/references.py b/jedi/inference/references.py index ff52cb56..963a16d3 100644 --- a/jedi/inference/references.py +++ b/jedi/inference/references.py @@ -25,7 +25,7 @@ easily 100ms for bigger files. """ -def _resolve_names(definition_names, avoid_names=(), all_scopes=True): +def _resolve_names(definition_names, avoid_names=()): for name in definition_names: if name in avoid_names: # Avoiding recursions here, because goto on a module name lands @@ -37,7 +37,7 @@ def _resolve_names(definition_names, avoid_names=(), all_scopes=True): # names when importing something like `import foo.bar.baz`. yield name - if all_scopes and name.api_type == 'module': + if name.api_type == 'module': for n in _resolve_names(name.goto(), definition_names): yield n @@ -49,17 +49,16 @@ def _dictionarize(names): ) -def _find_defining_names(module_context, tree_name, all_scopes=True): - found_names = _find_names(module_context, tree_name, all_scopes=all_scopes) +def _find_defining_names(module_context, tree_name): + found_names = _find_names(module_context, tree_name) - if all_scopes: - for name in list(found_names): - # Convert from/to stubs, because those might also be usages. - found_names |= set(convert_names( - [name], - only_stubs=not name.get_root_context().is_stub(), - prefer_stub_to_compiled=False - )) + for name in list(found_names): + # Convert from/to stubs, because those might also be usages. + found_names |= set(convert_names( + [name], + only_stubs=not name.get_root_context().is_stub(), + prefer_stub_to_compiled=False + )) found_names |= set(_find_global_variables(found_names, tree_name.value)) for name in list(found_names): @@ -67,15 +66,15 @@ def _find_defining_names(module_context, tree_name, all_scopes=True): or name.tree_name.parent.type == 'trailer': continue found_names |= set(_add_names_in_same_context(name.parent_context, name.string_name)) - return set(_resolve_names(found_names, all_scopes=all_scopes)) + return set(_resolve_names(found_names)) -def _find_names(module_context, tree_name, all_scopes=True): +def _find_names(module_context, tree_name): name = module_context.create_name(tree_name) - found_names = set(name.goto(all_scopes=all_scopes)) + found_names = set(name.goto()) found_names.add(name) - return set(_resolve_names(found_names, all_scopes=all_scopes)) + return set(_resolve_names(found_names)) def _add_names_in_same_context(context, string_name): @@ -114,7 +113,7 @@ def _find_global_variables(names, search_name): yield n -def find_references(module_context, tree_name, all_scopes=True): +def find_references(module_context, tree_name, only_in_module=False): inf = module_context.inference_state search_name = tree_name.value @@ -122,20 +121,20 @@ def find_references(module_context, tree_name, all_scopes=True): # certain cases, we want both sides. try: inf.flow_analysis_enabled = False - found_names = _find_defining_names(module_context, tree_name, all_scopes=all_scopes) + found_names = _find_defining_names(module_context, tree_name) finally: inf.flow_analysis_enabled = True found_names_dct = _dictionarize(found_names) module_contexts = [module_context] - if all_scopes: + if not only_in_module: module_contexts.extend( m for m in set(d.get_root_context() for d in found_names) if m != module_context and m.tree_node is not None ) # For param no search for other modules is necessary. - if not all_scopes or any(n.api_type == 'param' for n in found_names): + if only_in_module or any(n.api_type == 'param' for n in found_names): potential_modules = module_contexts else: potential_modules = get_module_contexts_containing_name( @@ -144,15 +143,10 @@ def find_references(module_context, tree_name, all_scopes=True): search_name, ) - gotos = set() - if not all_scopes: - for name in found_names_dct.values(): - gotos |= set(name.goto()) - non_matching_reference_maps = {} for module_context in potential_modules: for name_leaf in module_context.tree_node.get_used_names().get(search_name, []): - new = _dictionarize(_find_names(module_context, name_leaf, all_scopes=all_scopes)) + new = _dictionarize(_find_names(module_context, name_leaf)) if any(tree_name in found_names_dct for tree_name in new): found_names_dct.update(new) for tree_name in new: @@ -167,19 +161,10 @@ def find_references(module_context, tree_name, all_scopes=True): else: for name in new: non_matching_reference_maps.setdefault(name, []).append(new) - - if not all_scopes: - def in_gotos(g): - for g_ in gotos: - if g.start_pos == g_.start_pos and g.get_root_context() == g_.get_root_context(): - return True - - for dct_list in non_matching_reference_maps.values(): - for dct in dct_list: - for k, v in dct.items(): - if any(in_gotos(g) for g in v.goto()): - found_names_dct[k] = v - return found_names_dct.values() + result = found_names_dct.values() + if only_in_module: + return [n for n in result if n.get_root_context() == module_context] + return result def _check_fs(inference_state, file_io, regex): diff --git a/jedi/plugins/pytest.py b/jedi/plugins/pytest.py index 76754394..f9b04284 100644 --- a/jedi/plugins/pytest.py +++ b/jedi/plugins/pytest.py @@ -63,7 +63,7 @@ def infer_anonymous_param(func): def goto_anonymous_param(func): - def wrapper(param_name, **kwargs): + def wrapper(param_name): is_pytest_param, param_name_is_function_name = \ _is_a_pytest_param_and_inherited(param_name) if is_pytest_param: @@ -74,7 +74,7 @@ def goto_anonymous_param(func): ) if names: return names - return func(param_name, **kwargs) + return func(param_name) return wrapper diff --git a/test/test_api/test_usages.py b/test/test_api/test_usages.py index 27d9d300..cef18fb8 100644 --- a/test/test_api/test_usages.py +++ b/test/test_api/test_usages.py @@ -38,7 +38,7 @@ foo() ''', project=project) def r(*args): - return script.get_references(all_scopes=False, *args) + return script.get_references(scope='file', *args) print(script._code_lines) sys_places = r(1, 7) @@ -79,9 +79,9 @@ def test_local_references_method_other_file(Script): d1 = datetime.now() d2 = datetime.now() ''', project=Project('', sys_path=[], smart_sys_path=False)) - now_places = script.get_references(2, 14, all_scopes=False) + now_places = script.get_references(2, 14, scope='file') assert len(now_places) == 2 - assert now_places == script.get_references(3, 14, all_scopes=False) + assert now_places == script.get_references(3, 14, scope='file') def test_local_references_kwarg(Script): @@ -89,4 +89,4 @@ def test_local_references_kwarg(Script): script = Script('''from jedi import Script Script(code='') ''', project=Project('', sys_path=[], smart_sys_path=False)) - assert len(script.get_references(2, 7, all_scopes=False)) == 1 + assert len(script.get_references(2, 7, scope='file')) == 1