forked from VimPlug/jedi
394 lines
13 KiB
Python
394 lines
13 KiB
Python
from abc import abstractmethod
|
|
|
|
from parso.tree import search_ancestor
|
|
from parso.python.tree import Name, Param
|
|
|
|
from jedi.inference.filters import ParserTreeFilter, MergedFilter, \
|
|
GlobalNameFilter
|
|
from jedi import parser_utils
|
|
|
|
|
|
class AbstractContext(object):
|
|
# Must be defined: inference_state and tree_node and parent_context as an attribute/property
|
|
|
|
def __init__(self, inference_state):
|
|
self.inference_state = inference_state
|
|
self.predefined_names = {}
|
|
|
|
@abstractmethod
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
raise NotImplementedError
|
|
|
|
def goto(self, name_or_str, position):
|
|
return self._goto(name_or_str, position)[0]
|
|
|
|
def _goto(self, name_or_str, position):
|
|
from jedi.inference import finder
|
|
f = finder.NameFinder(self.inference_state, self, self, name_or_str, position)
|
|
filters = _get_global_filters_for_name(
|
|
self, name_or_str if isinstance(name_or_str, Name) else None, position,
|
|
)
|
|
return f.filter_name(filters), f
|
|
|
|
def py__getattribute__(self, name_or_str, name_context=None, position=None,
|
|
analysis_errors=True):
|
|
"""
|
|
:param position: Position of the last statement -> tuple of line, column
|
|
"""
|
|
if name_context is None:
|
|
name_context = self
|
|
names, f = self._goto(name_or_str, position)
|
|
values = f.find(names, attribute_lookup=False)
|
|
if not names and analysis_errors and not values \
|
|
and not (isinstance(name_or_str, Name) and
|
|
isinstance(name_or_str.parent.parent, Param)):
|
|
if isinstance(name_or_str, Name):
|
|
from jedi.inference import analysis
|
|
message = ("NameError: name '%s' is not defined."
|
|
% name_or_str if isinstance(name_or_str, Name) else name_or_str)
|
|
analysis.add(name_context, 'name-error', name_or_str, message)
|
|
return values
|
|
|
|
def get_root_context(self):
|
|
parent_context = self.parent_context
|
|
if parent_context is None:
|
|
return self
|
|
return parent_context.get_root_context()
|
|
|
|
def is_module(self):
|
|
return False
|
|
|
|
def is_builtins_module(self):
|
|
return False
|
|
|
|
def is_class(self):
|
|
return False
|
|
|
|
def is_stub(self):
|
|
return False
|
|
|
|
def is_instance(self):
|
|
return False
|
|
|
|
def is_compiled(self):
|
|
return False
|
|
|
|
@abstractmethod
|
|
def py__name__(self):
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def name(self):
|
|
return None
|
|
|
|
def get_qualified_names(self):
|
|
return ()
|
|
|
|
def py__doc__(self):
|
|
return ''
|
|
|
|
def __repr__(self):
|
|
return '%s(%s)' % (self.__class__.__name__, self._value)
|
|
|
|
|
|
class ValueContext(AbstractContext):
|
|
"""
|
|
Should be defined, otherwise the API returns empty types.
|
|
"""
|
|
def __init__(self, value):
|
|
super(ValueContext, self).__init__(value.inference_state)
|
|
self._value = value
|
|
|
|
@property
|
|
def tree_node(self):
|
|
return self._value.tree_node
|
|
|
|
@property
|
|
def parent_context(self):
|
|
return self._value.parent_context
|
|
|
|
def is_module(self):
|
|
return self._value.is_module()
|
|
|
|
def is_builtins_module(self):
|
|
return self._value == self.inference_state.builtins_module
|
|
|
|
def is_class(self):
|
|
return self._value.is_class()
|
|
|
|
def is_stub(self):
|
|
return self._value.is_stub()
|
|
|
|
def is_instance(self):
|
|
return self._value.is_instance()
|
|
|
|
def is_compiled(self):
|
|
return self._value.is_compiled()
|
|
|
|
def py__name__(self):
|
|
return self._value.py__name__()
|
|
|
|
@property
|
|
def name(self):
|
|
return self._value.name
|
|
|
|
def get_qualified_names(self):
|
|
return self._value.get_qualified_names()
|
|
|
|
def py__doc__(self):
|
|
return self._value.py__doc__()
|
|
|
|
def __repr__(self):
|
|
return '%s(%s)' % (self.__class__.__name__, self._value)
|
|
|
|
|
|
class TreeContextMixin(object):
|
|
def infer_node(self, node):
|
|
return self.inference_state.infer_element(self, node)
|
|
|
|
def create_value(self, node):
|
|
from jedi.inference import value
|
|
|
|
if node == self.tree_node:
|
|
assert self.is_module()
|
|
return self.get_value()
|
|
|
|
parent_context = self.create_context(node)
|
|
|
|
if node.type in ('funcdef', 'lambdef'):
|
|
func = value.FunctionValue.from_context(parent_context, node)
|
|
if parent_context.is_class():
|
|
class_value = parent_context.parent_context.create_value(parent_context.tree_node)
|
|
instance = value.AnonymousInstance(
|
|
self.inference_state, parent_context.parent_context, class_value)
|
|
func = value.BoundMethod(
|
|
instance=instance,
|
|
function=func
|
|
)
|
|
return func
|
|
elif node.type == 'classdef':
|
|
return value.ClassValue(self.inference_state, parent_context, node)
|
|
else:
|
|
raise NotImplementedError("Probably shouldn't happen: %s" % node)
|
|
|
|
def create_context(self, node):
|
|
def from_scope_node(scope_node, is_nested=True):
|
|
if scope_node == self.tree_node:
|
|
return self
|
|
|
|
if scope_node.type in ('funcdef', 'lambdef', 'classdef'):
|
|
return self.create_value(scope_node).as_context()
|
|
elif scope_node.type in ('comp_for', 'sync_comp_for'):
|
|
parent_scope = parser_utils.get_parent_scope(scope_node)
|
|
parent_context = from_scope_node(parent_scope)
|
|
if node.start_pos >= scope_node.children[-1].start_pos:
|
|
return parent_context
|
|
return CompForContext(parent_context, scope_node)
|
|
raise Exception("There's a scope that was not managed: %s" % scope_node)
|
|
|
|
def parent_scope(node):
|
|
while True:
|
|
node = node.parent
|
|
|
|
if parser_utils.is_scope(node):
|
|
return node
|
|
elif node.type in ('argument', 'testlist_comp'):
|
|
if node.children[1].type in ('comp_for', 'sync_comp_for'):
|
|
return node.children[1]
|
|
elif node.type == 'dictorsetmaker':
|
|
for n in node.children[1:4]:
|
|
# In dictionaries it can be pretty much anything.
|
|
if n.type in ('comp_for', 'sync_comp_for'):
|
|
return n
|
|
|
|
scope_node = parent_scope(node)
|
|
if scope_node.type in ('funcdef', 'classdef'):
|
|
colon = scope_node.children[scope_node.children.index(':')]
|
|
if node.start_pos < colon.start_pos:
|
|
parent = node.parent
|
|
if not (parent.type == 'param' and parent.name == node):
|
|
scope_node = parent_scope(scope_node)
|
|
return from_scope_node(scope_node, is_nested=True)
|
|
|
|
|
|
class FunctionContext(TreeContextMixin, ValueContext):
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
yield ParserTreeFilter(
|
|
self.inference_state,
|
|
parent_context=self,
|
|
until_position=until_position,
|
|
origin_scope=origin_scope
|
|
)
|
|
|
|
|
|
class ModuleContext(TreeContextMixin, ValueContext):
|
|
def py__file__(self):
|
|
return self._value.py__file__()
|
|
|
|
@property
|
|
def py__package__(self):
|
|
return self._value.py__package__
|
|
|
|
@property
|
|
def is_package(self):
|
|
return self._value.is_package
|
|
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
filters = self._value.get_filters(origin_scope)
|
|
# Skip the first filter and replace it.
|
|
next(filters)
|
|
yield MergedFilter(
|
|
ParserTreeFilter(
|
|
parent_context=self,
|
|
until_position=until_position,
|
|
origin_scope=origin_scope
|
|
),
|
|
GlobalNameFilter(self, self.tree_node),
|
|
)
|
|
for f in filters: # Python 2...
|
|
yield f
|
|
|
|
@property
|
|
def string_names(self):
|
|
return self._value.string_names
|
|
|
|
@property
|
|
def code_lines(self):
|
|
return self._value.code_lines
|
|
|
|
def get_value(self):
|
|
"""
|
|
This is the only function that converts a context back to a value.
|
|
This is necessary for stub -> python conversion and vice versa. However
|
|
this method shouldn't be moved to AbstractContext.
|
|
"""
|
|
return self._value
|
|
|
|
|
|
class NamespaceContext(TreeContextMixin, ValueContext):
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
return self._value.get_filters()
|
|
|
|
def py__file__(self):
|
|
return self._value.py__file__()
|
|
|
|
|
|
class ClassContext(TreeContextMixin, ValueContext):
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
yield self.get_global_filter(until_position, origin_scope)
|
|
|
|
def get_global_filter(self, until_position=None, origin_scope=None):
|
|
return ParserTreeFilter(
|
|
parent_context=self,
|
|
until_position=until_position,
|
|
origin_scope=origin_scope
|
|
)
|
|
|
|
|
|
class CompForContext(TreeContextMixin, AbstractContext):
|
|
def __init__(self, parent_context, comp_for):
|
|
super(CompForContext, self).__init__(parent_context.inference_state)
|
|
self.tree_node = comp_for
|
|
self.parent_context = parent_context
|
|
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
yield ParserTreeFilter(self)
|
|
|
|
|
|
class CompiledContext(ValueContext):
|
|
def get_filters(self, until_position=None, origin_scope=None):
|
|
return self._value.get_filters()
|
|
|
|
def get_value(self):
|
|
return self._value
|
|
|
|
def py__file__(self):
|
|
return self._value.py__file__()
|
|
|
|
|
|
def _get_global_filters_for_name(context, name_or_none, position):
|
|
# For functions and classes the defaults don't belong to the
|
|
# function and get inferred in the value before the function. So
|
|
# make sure to exclude the function/class name.
|
|
if name_or_none is not None:
|
|
ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef', 'lambdef')
|
|
lambdef = None
|
|
if ancestor == 'lambdef':
|
|
# For lambdas it's even more complicated since parts will
|
|
# be inferred later.
|
|
lambdef = ancestor
|
|
ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef')
|
|
if ancestor is not None:
|
|
colon = ancestor.children[-2]
|
|
if position is not None and position < colon.start_pos:
|
|
if lambdef is None or position < lambdef.children[-2].start_pos:
|
|
position = ancestor.start_pos
|
|
|
|
return get_global_filters(context, position, name_or_none)
|
|
|
|
|
|
def get_global_filters(context, until_position, origin_scope):
|
|
"""
|
|
Returns all filters in order of priority for name resolution.
|
|
|
|
For global name lookups. The filters will handle name resolution
|
|
themselves, but here we gather possible filters downwards.
|
|
|
|
>>> from jedi._compatibility import u, no_unicode_pprint
|
|
>>> from jedi import Script
|
|
>>> script = Script(u('''
|
|
... x = ['a', 'b', 'c']
|
|
... def func():
|
|
... y = None
|
|
... '''))
|
|
>>> module_node = script._module_node
|
|
>>> scope = next(module_node.iter_funcdefs())
|
|
>>> scope
|
|
<Function: func@3-5>
|
|
>>> context = script._get_module_context().create_context(scope)
|
|
>>> filters = list(get_global_filters(context, (4, 0), None))
|
|
|
|
First we get the names from the function scope.
|
|
|
|
>>> no_unicode_pprint(filters[0]) # doctest: +ELLIPSIS
|
|
MergedFilter(<ParserTreeFilter: ...>, <GlobalNameFilter: ...>)
|
|
>>> sorted(str(n) for n in filters[0].values()) # doctest: +NORMALIZE_WHITESPACE
|
|
['<TreeNameDefinition: string_name=func start_pos=(3, 4)>',
|
|
'<TreeNameDefinition: string_name=x start_pos=(2, 0)>']
|
|
>>> filters[0]._filters[0]._until_position
|
|
(4, 0)
|
|
>>> filters[0]._filters[1]._until_position
|
|
|
|
Then it yields the names from one level "lower". In this example, this is
|
|
the module scope (including globals).
|
|
As a side note, you can see, that the position in the filter is None on the
|
|
globals filter, because there the whole module is searched.
|
|
|
|
>>> list(filters[1].values()) # package modules -> Also empty.
|
|
[]
|
|
>>> sorted(name.string_name for name in filters[2].values()) # Module attributes
|
|
['__doc__', '__name__', '__package__']
|
|
|
|
Finally, it yields the builtin filter, if `include_builtin` is
|
|
true (default).
|
|
|
|
>>> list(filters[3].values()) # doctest: +ELLIPSIS
|
|
[...]
|
|
"""
|
|
base_context = context
|
|
from jedi.inference.value.function import FunctionExecutionContext
|
|
while context is not None:
|
|
# Names in methods cannot be resolved within the class.
|
|
for filter in context.get_filters(
|
|
until_position=until_position,
|
|
origin_scope=origin_scope):
|
|
yield filter
|
|
if isinstance(context, FunctionExecutionContext):
|
|
# The position should be reset if the current scope is a function.
|
|
until_position = None
|
|
|
|
context = context.parent_context
|
|
|
|
# Add builtins to the global scope.
|
|
yield next(base_context.inference_state.builtins_module.get_filters())
|