mirror of
https://github.com/davidhalter/jedi.git
synced 2025-12-16 02:27:06 +08:00
375 lines
15 KiB
Python
375 lines
15 KiB
Python
from jedi._compatibility import hasattr, unicode, u
|
|
from jedi.parser import representation as pr
|
|
from jedi import debug
|
|
from jedi import common
|
|
from jedi import settings
|
|
from jedi.evaluate import representation as er
|
|
from jedi.evaluate import dynamic
|
|
from jedi.evaluate import builtin
|
|
from jedi.evaluate import docstrings
|
|
from jedi.evaluate import iterable
|
|
|
|
|
|
class NameFinder(object):
|
|
def __init__(self, evaluator, scope, name_str, position=None):
|
|
self._evaluator = evaluator
|
|
self.scope = scope
|
|
self.name_str = name_str
|
|
self.position = position
|
|
|
|
def _resolve_descriptors(self, types):
|
|
"""Processes descriptors"""
|
|
result = []
|
|
for r in types:
|
|
if isinstance(self.scope, (er.Instance, er.Class)) \
|
|
and hasattr(r, 'get_descriptor_return'):
|
|
# handle descriptors
|
|
with common.ignored(KeyError):
|
|
result += r.get_descriptor_return(self.scope)
|
|
continue
|
|
result.append(r)
|
|
return result
|
|
|
|
def _remove_statements(self, result, resolve_decorator=True):
|
|
"""
|
|
This is the part where statements are being stripped.
|
|
|
|
Due to lazy evaluation, statements like a = func; b = a; b() have to be
|
|
evaluated.
|
|
"""
|
|
evaluator = self._evaluator
|
|
res_new = []
|
|
for r in result:
|
|
add = []
|
|
if r.isinstance(pr.Statement):
|
|
check_instance = None
|
|
if isinstance(r, er.InstanceElement) and r.is_class_var:
|
|
check_instance = r.instance
|
|
r = r.var
|
|
|
|
# Global variables handling.
|
|
if r.is_global():
|
|
for token_name in r.token_list[1:]:
|
|
if isinstance(token_name, pr.Name):
|
|
add = evaluator.find_types(r.parent, str(token_name))
|
|
else:
|
|
# generated objects are used within executions, but these
|
|
# objects are in functions, and we have to dynamically
|
|
# execute first.
|
|
if isinstance(r, pr.Param):
|
|
func = r.parent
|
|
# Instances are typically faked, if the instance is not
|
|
# called from outside. Here we check it for __init__
|
|
# functions and return.
|
|
if isinstance(func, er.InstanceElement) \
|
|
and func.instance.is_generated \
|
|
and hasattr(func, 'name') \
|
|
and str(func.name) == '__init__' \
|
|
and r.position_nr > 0: # 0 would be self
|
|
r = func.var.params[r.position_nr]
|
|
|
|
# add docstring knowledge
|
|
doc_params = docstrings.follow_param(evaluator, r)
|
|
if doc_params:
|
|
res_new += doc_params
|
|
continue
|
|
|
|
if not r.is_generated:
|
|
res_new += dynamic.search_params(evaluator, r)
|
|
if not res_new:
|
|
c = r.expression_list()[0]
|
|
if c in ('*', '**'):
|
|
t = 'tuple' if c == '*' else 'dict'
|
|
res_new = evaluator.execute(evaluator.find_types(builtin.Builtin.scope, t)[0])
|
|
if not r.assignment_details:
|
|
# this means that there are no default params,
|
|
# so just ignore it.
|
|
continue
|
|
|
|
# Remove the statement docstr stuff for now, that has to be
|
|
# implemented with the evaluator class.
|
|
#if r.docstr:
|
|
#res_new.append(r)
|
|
|
|
scopes = evaluator.eval_statement(r, seek_name=self.name_str)
|
|
add += self._remove_statements(scopes)
|
|
|
|
if check_instance is not None:
|
|
# class renames
|
|
add = [er.InstanceElement(evaluator, check_instance, a, True)
|
|
if isinstance(a, (er.Function, pr.Function))
|
|
else a for a in add]
|
|
res_new += add
|
|
else:
|
|
if isinstance(r, pr.Class):
|
|
r = er.Class(evaluator, r)
|
|
elif isinstance(r, pr.Function):
|
|
r = er.Function(evaluator, r)
|
|
if r.isinstance(er.Function) and resolve_decorator:
|
|
r = r.get_decorated_func()
|
|
res_new.append(r)
|
|
debug.dbg('sfn remove, new: %s, old: %s' % (res_new, result))
|
|
return res_new
|
|
|
|
def _handle_for_loops(self, loop):
|
|
# Take the first statement (for has always only
|
|
# one, remember `in`). And follow it.
|
|
if not loop.inputs:
|
|
return []
|
|
result = iterable.get_iterator_types(self._evaluator.eval_statement(loop.inputs[0]))
|
|
if len(loop.set_vars) > 1:
|
|
expression_list = loop.set_stmt.expression_list()
|
|
# loops with loop.set_vars > 0 only have one command
|
|
from jedi import evaluate
|
|
result = evaluate._assign_tuples(expression_list[0], result, self.name_str)
|
|
return result
|
|
|
|
def _process(self, name):
|
|
"""
|
|
Returns the parent of a name, which means the element which stands
|
|
behind a name.
|
|
"""
|
|
result = []
|
|
no_break_scope = False
|
|
par = name.parent
|
|
exc = pr.Class, pr.Function
|
|
until = lambda: par.parent.parent.get_parent_until(exc)
|
|
is_array_assignment = False
|
|
|
|
if par is None:
|
|
pass
|
|
elif par.isinstance(pr.Flow):
|
|
if par.command == 'for':
|
|
result += self._handle_for_loops(par)
|
|
else:
|
|
debug.warning('Flow: Why are you here? %s' % par.command)
|
|
elif par.isinstance(pr.Param) \
|
|
and par.parent is not None \
|
|
and isinstance(until(), pr.Class) \
|
|
and par.position_nr == 0:
|
|
# This is where self gets added - this happens at another
|
|
# place, if the var_args are clear. But sometimes the class is
|
|
# not known. Therefore add a new instance for self. Otherwise
|
|
# take the existing.
|
|
if isinstance(self.scope, er.InstanceElement):
|
|
result.append(self.scope.instance)
|
|
else:
|
|
for inst in self._evaluator.execute(er.Class(self._evaluator, until())):
|
|
inst.is_generated = True
|
|
result.append(inst)
|
|
elif par.isinstance(pr.Statement):
|
|
def is_execution(calls):
|
|
for c in calls:
|
|
if isinstance(c, (unicode, str)):
|
|
continue
|
|
if c.isinstance(pr.Array):
|
|
if is_execution(c):
|
|
return True
|
|
elif c.isinstance(pr.Call):
|
|
# Compare start_pos, because names may be different
|
|
# because of executions.
|
|
if c.name.start_pos == name.start_pos \
|
|
and c.execution:
|
|
return True
|
|
return False
|
|
|
|
is_exe = False
|
|
for assignee, op in par.assignment_details:
|
|
is_exe |= is_execution(assignee)
|
|
|
|
if is_exe:
|
|
# filter array[3] = ...
|
|
# TODO check executions for dict contents
|
|
is_array_assignment = True
|
|
else:
|
|
details = par.assignment_details
|
|
if details and details[0][1] != '=':
|
|
no_break_scope = True
|
|
|
|
# TODO this makes self variables non-breakable. wanted?
|
|
if isinstance(name, er.InstanceElement) \
|
|
and not name.is_class_var:
|
|
no_break_scope = True
|
|
|
|
result.append(par)
|
|
else:
|
|
# TODO multi-level import non-breakable
|
|
if isinstance(par, pr.Import) and len(par.namespace) > 1:
|
|
no_break_scope = True
|
|
result.append(par)
|
|
return result, no_break_scope, is_array_assignment
|
|
|
|
def filter_name(self, scope_generator, is_goto=False):
|
|
"""
|
|
Filters all variables of a scope (which are defined in the
|
|
`scope_generator`), until the name fits.
|
|
"""
|
|
flow_scope = self.scope
|
|
result = []
|
|
# compare func uses the tuple of line/indent = line/column
|
|
comparison_func = lambda name: (name.start_pos)
|
|
|
|
for nscope, name_list in scope_generator:
|
|
break_scopes = []
|
|
# here is the position stuff happening (sorting of variables)
|
|
for name in sorted(name_list, key=comparison_func, reverse=True):
|
|
p = name.parent.parent if name.parent else None
|
|
if isinstance(p, er.InstanceElement) \
|
|
and isinstance(p.var, pr.Class):
|
|
p = p.var
|
|
if self.name_str == name.get_code() and p not in break_scopes:
|
|
r, no_break_scope, is_array_assignment = self._process(name)
|
|
if is_goto:
|
|
if not is_array_assignment: # shouldn't goto arr[1] =
|
|
result.append(name)
|
|
else:
|
|
result += r
|
|
# for comparison we need the raw class
|
|
s = nscope.base if isinstance(nscope, er.Class) else nscope
|
|
# this means that a definition was found and is not e.g.
|
|
# in if/else.
|
|
if result and not no_break_scope:
|
|
if not name.parent or p == s:
|
|
break
|
|
break_scopes.append(p)
|
|
if result:
|
|
break
|
|
|
|
while flow_scope:
|
|
# TODO check if result is in scope -> no evaluation necessary
|
|
n = check_flow_information(self._evaluator, flow_scope,
|
|
self.name_str, self.position)
|
|
if n:
|
|
result = n
|
|
break
|
|
flow_scope = flow_scope.parent
|
|
|
|
if not result and isinstance(nscope, er.Instance):
|
|
# __getattr__ / __getattribute__
|
|
result += self._check_getattr(nscope)
|
|
debug.dbg('sfn filter "%s" in (%s-%s): %s@%s'
|
|
% (self.name_str, self.scope, nscope, u(result), self.position))
|
|
return result
|
|
|
|
def find(self, scopes, resolve_decorator=True):
|
|
filtered = self.filter_name(scopes)
|
|
return self._resolve_descriptors(self._remove_statements(filtered,
|
|
resolve_decorator))
|
|
|
|
def _check_getattr(self, inst):
|
|
"""Checks for both __getattr__ and __getattribute__ methods"""
|
|
result = []
|
|
# str is important to lose the NamePart!
|
|
module = builtin.Builtin.scope
|
|
name = pr.String(module, "'%s'" % self.name_str, (0, 0), (0, 0), inst)
|
|
with common.ignored(KeyError):
|
|
result = inst.execute_subscope_by_name('__getattr__', [name])
|
|
if not result:
|
|
# this is a little bit special. `__getattribute__` is executed
|
|
# before anything else. But: I know no use case, where this
|
|
# could be practical and the jedi would return wrong types. If
|
|
# you ever have something, let me know!
|
|
with common.ignored(KeyError):
|
|
result = inst.execute_subscope_by_name('__getattribute__', [name])
|
|
return result
|
|
|
|
def scopes(self, search_global=False):
|
|
if search_global:
|
|
return self._evaluator.get_names_of_scope(self.scope, self.position)
|
|
else:
|
|
if isinstance(self.scope, er.Instance):
|
|
return self.scope.scope_generator()
|
|
else:
|
|
if isinstance(self.scope, (er.Class, pr.Module)):
|
|
# classes are only available directly via chaining?
|
|
# strange stuff...
|
|
names = self.scope.get_defined_names()
|
|
else:
|
|
names = _get_defined_names_for_position(self.scope, self.position)
|
|
return iter([(self.scope, names)])
|
|
|
|
|
|
def check_flow_information(evaluator, flow, search_name, pos):
|
|
""" Try to find out the type of a variable just with the information that
|
|
is given by the flows: e.g. It is also responsible for assert checks.::
|
|
|
|
if isinstance(k, str):
|
|
k. # <- completion here
|
|
|
|
ensures that `k` is a string.
|
|
"""
|
|
if not settings.dynamic_flow_information:
|
|
return None
|
|
|
|
result = []
|
|
if isinstance(flow, pr.IsScope) and not result:
|
|
for ass in reversed(flow.asserts):
|
|
if pos is None or ass.start_pos > pos:
|
|
continue
|
|
result = _check_isinstance_type(evaluator, ass, search_name)
|
|
if result:
|
|
break
|
|
|
|
if isinstance(flow, pr.Flow) and not result:
|
|
if flow.command in ['if', 'while'] and len(flow.inputs) == 1:
|
|
result = _check_isinstance_type(evaluator, flow.inputs[0], search_name)
|
|
return result
|
|
|
|
|
|
def _check_isinstance_type(evaluator, stmt, search_name):
|
|
try:
|
|
expression_list = stmt.expression_list()
|
|
# this might be removed if we analyze and, etc
|
|
assert len(expression_list) == 1
|
|
call = expression_list[0]
|
|
assert isinstance(call, pr.Call) and str(call.name) == 'isinstance'
|
|
assert bool(call.execution)
|
|
|
|
# isinstance check
|
|
isinst = call.execution.values
|
|
assert len(isinst) == 2 # has two params
|
|
obj, classes = [statement.expression_list() for statement in isinst]
|
|
assert len(obj) == 1
|
|
assert len(classes) == 1
|
|
assert isinstance(obj[0], pr.Call)
|
|
# names fit?
|
|
assert str(obj[0].name) == search_name
|
|
assert isinstance(classes[0], pr.StatementElement) # can be type or tuple
|
|
except AssertionError:
|
|
return []
|
|
|
|
result = []
|
|
for c in evaluator.eval_call(classes[0]):
|
|
for typ in (c.get_index_types() if isinstance(c, iterable.Array) else [c]):
|
|
result += evaluator.execute(typ)
|
|
return result
|
|
|
|
|
|
def _get_defined_names_for_position(scope, position=None, start_scope=None):
|
|
"""
|
|
Return filtered version of ``scope.get_defined_names()``.
|
|
|
|
This function basically does what :meth:`scope.get_defined_names
|
|
<parsing_representation.Scope.get_defined_names>` does.
|
|
|
|
- If `position` is given, delete all names defined after `position`.
|
|
- For special objects like instances, `position` is ignored and all
|
|
names are returned.
|
|
|
|
:type scope: :class:`parsing_representation.IsScope`
|
|
:param scope: Scope in which names are searched.
|
|
:param position: The position as a line/column tuple, default is infinity.
|
|
"""
|
|
names = scope.get_defined_names()
|
|
# Instances have special rules, always return all the possible completions,
|
|
# because class variables are always valid and the `self.` variables, too.
|
|
if (not position or isinstance(scope, (iterable.Array, er.Instance))
|
|
or start_scope != scope
|
|
and isinstance(start_scope, (pr.Function, er.FunctionExecution))):
|
|
return names
|
|
names_new = []
|
|
for n in names:
|
|
if n.start_pos[0] is not None and n.start_pos < position:
|
|
names_new.append(n)
|
|
return names_new
|