Esempio n. 1
0
def usages_with_additional_modules(
    script: jedi.api.Script,
    additional_module_contexts: Tuple[ModuleContext] = ()):
    """
    Based on `jedi.api.Script.usages`, except `additional_modules` are also searched

    Forked from `jedi.api.Script.usages` on 2017-02-02.

    Return :class:`classes.Definition` objects, which contain all
    names that point to the definition of the name under the cursor. This
    is very useful for refactoring (renaming), or to show all usages of a
    variable.

    .. todo:: Implement additional_module_paths

    :rtype: list of :class:`classes.Definition`
    """
    from jedi import settings
    from jedi.api import usages
    from jedi.api import helpers
    from . import api_usages as alt_api_usages

    self = script

    temp, settings.dynamic_flow_information = \
        settings.dynamic_flow_information, False
    try:
        module_node = self._get_module_node()
        user_stmt = module_node.get_statement_for_position(self._pos)
        definition_names = self._goto()

        #assert not definition_names
        if not definition_names and isinstance(user_stmt, tree_Import):
            # For not defined imports (goto doesn't find something, we take
            # the name as a definition. This is enough, because every name
            # points to it.
            name = user_stmt.name_for_position(self._pos)
            if name is None:
                # Must be syntax
                return []
            definition_names = [TreeNameDefinition(self._get_module(), name)]

        if not definition_names:
            # Without a definition for a name we cannot find references.
            return []

        definition_names = usages.resolve_potential_imports(
            self._evaluator, definition_names)

        modules = set([d.get_root_context() for d in definition_names])
        modules.add(self._get_module())
        for additional_module_context in additional_module_contexts:
            modules.add(additional_module_context)
        definitions = alt_api_usages.usages(self._evaluator, definition_names,
                                            modules)
    finally:
        settings.dynamic_flow_information = temp

    return helpers.sorted_definitions(set(definitions))
    def usages(self, additional_module_paths=()):
        """
        Return :class:`classes.Definition` objects, which contain all
        names that point to the definition of the name under the cursor. This
        is very useful for refactoring (renaming), or to show all usages of a
        variable.

        .. todo:: Implement additional_module_paths

        :rtype: list of :class:`classes.Definition`
        """
        temp, settings.dynamic_flow_information = \
            settings.dynamic_flow_information, False
        try:
            module_node = self._get_module_node()
            user_stmt = get_statement_of_position(module_node, self._pos)
            definition_names = self._goto()
            if not definition_names and isinstance(user_stmt, tree.Import):
                # For not defined imports (goto doesn't find something, we take
                # the name as a definition. This is enough, because every name
                # points to it.
                name = user_stmt.get_name_of_position(self._pos)
                if name is None:
                    # Must be syntax
                    return []
                definition_names = [
                    TreeNameDefinition(self._get_module(), name)
                ]

            if not definition_names:
                # Without a definition for a name we cannot find references.
                return []

            definition_names = usages.resolve_potential_imports(
                self._evaluator, definition_names)

            modules = set([d.get_root_context() for d in definition_names])
            modules.add(self._get_module())
            definitions = usages.usages(self._evaluator, definition_names,
                                        modules)
        finally:
            settings.dynamic_flow_information = temp

        return helpers.sorted_definitions(set(definitions))
Esempio n. 3
0
    def usages(self, additional_module_paths=()):
        """
        Return :class:`classes.Definition` objects, which contain all
        names that point to the definition of the name under the cursor. This
        is very useful for refactoring (renaming), or to show all usages of a
        variable.

        .. todo:: Implement additional_module_paths

        :rtype: list of :class:`classes.Definition`
        """
        temp, settings.dynamic_flow_information = \
            settings.dynamic_flow_information, False
        try:
            module_node = self._get_module_node()
            user_stmt = get_statement_of_position(module_node, self._pos)
            definition_names = self._goto()
            if not definition_names and isinstance(user_stmt, tree.Import):
                # For not defined imports (goto doesn't find something, we take
                # the name as a definition. This is enough, because every name
                # points to it.
                name = user_stmt.get_name_of_position(self._pos)
                if name is None:
                    # Must be syntax
                    return []
                definition_names = [TreeNameDefinition(self._get_module(), name)]

            if not definition_names:
                # Without a definition for a name we cannot find references.
                return []

            definition_names = usages.resolve_potential_imports(self._evaluator,
                                                                definition_names)

            modules = set([d.get_root_context() for d in definition_names])
            modules.add(self._get_module())
            definitions = usages.usages(self._evaluator, definition_names, modules)
        finally:
            settings.dynamic_flow_information = temp

        return helpers.sorted_definitions(set(definitions))