forked from VimPlug/jedi
150 lines
4.7 KiB
Python
150 lines
4.7 KiB
Python
"""
|
|
One of the really important features of |jedi| is to have an option to
|
|
understand code like this::
|
|
|
|
def foo(bar):
|
|
bar. # completion here
|
|
foo(1)
|
|
|
|
There's no doubt wheter bar is an ``int`` or not, but if there's also a call
|
|
like ``foo('str')``, what would happen? Well, we'll just show both. Because
|
|
that's what a human would expect.
|
|
|
|
It works as follows:
|
|
|
|
- |Jedi| sees a param
|
|
- search for function calls named ``foo``
|
|
- execute these calls and check the input. This work with a ``ParamListener``.
|
|
"""
|
|
from itertools import chain
|
|
|
|
from jedi._compatibility import unicode
|
|
from jedi.parser import tree
|
|
from jedi import settings
|
|
from jedi import debug
|
|
from jedi.evaluate.cache import memoize_default
|
|
from jedi.evaluate import imports
|
|
|
|
|
|
MAX_PARAM_SEARCHES = 10
|
|
|
|
|
|
class ParamListener(object):
|
|
"""
|
|
This listener is used to get the params for a function.
|
|
"""
|
|
def __init__(self):
|
|
self.param_possibilities = []
|
|
|
|
def execute(self, params):
|
|
self.param_possibilities += params
|
|
|
|
|
|
@debug.increase_indent
|
|
def search_params(evaluator, param):
|
|
"""
|
|
A dynamic search for param values. If you try to complete a type:
|
|
|
|
>>> def func(foo):
|
|
... foo
|
|
>>> func(1)
|
|
>>> func("")
|
|
|
|
It is not known what the type ``foo`` without analysing the whole code. You
|
|
have to look for all calls to ``func`` to find out what ``foo`` possibly
|
|
is.
|
|
"""
|
|
if not settings.dynamic_params:
|
|
return set()
|
|
|
|
evaluator.dynamic_params_depth += 1
|
|
try:
|
|
func = param.get_parent_until(tree.Function)
|
|
debug.dbg('Dynamic param search for %s in %s.', param, str(func.name), color='MAGENTA')
|
|
# Compare the param names.
|
|
names = [n for n in search_function_call(evaluator, func)
|
|
if n.value == param.name.value]
|
|
# Evaluate the ExecutedParams to types.
|
|
result = set(chain.from_iterable(n.parent.eval(evaluator) for n in names))
|
|
debug.dbg('Dynamic param result %s', result, color='MAGENTA')
|
|
return result
|
|
finally:
|
|
evaluator.dynamic_params_depth -= 1
|
|
|
|
|
|
@memoize_default([], evaluator_is_first_arg=True)
|
|
def search_function_call(evaluator, func):
|
|
"""
|
|
Returns a list of param names.
|
|
"""
|
|
from jedi.evaluate import representation as er
|
|
|
|
def get_possible_nodes(module, func_name):
|
|
try:
|
|
names = module.used_names[func_name]
|
|
except KeyError:
|
|
return
|
|
|
|
for name in names:
|
|
bracket = name.get_next_leaf()
|
|
trailer = bracket.parent
|
|
if trailer.type == 'trailer' and bracket == '(':
|
|
yield name, trailer
|
|
|
|
def undecorate(typ):
|
|
# We have to remove decorators, because they are not the
|
|
# "original" functions, this way we can easily compare.
|
|
# At the same time we also have to remove InstanceElements.
|
|
if typ.isinstance(er.Function, er.Instance) \
|
|
and typ.decorates is not None:
|
|
return typ.decorates
|
|
elif isinstance(typ, er.InstanceElement):
|
|
return typ.var
|
|
else:
|
|
return typ
|
|
|
|
current_module = func.get_parent_until()
|
|
func_name = unicode(func.name)
|
|
compare = func
|
|
if func_name == '__init__':
|
|
cls = func.get_parent_scope()
|
|
if isinstance(cls, tree.Class):
|
|
func_name = unicode(cls.name)
|
|
compare = cls
|
|
|
|
# add the listener
|
|
listener = ParamListener()
|
|
func.listeners.add(listener)
|
|
|
|
try:
|
|
result = []
|
|
i = 0
|
|
for mod in imports.get_modules_containing_name(evaluator, [current_module], func_name):
|
|
for name, trailer in get_possible_nodes(mod, func_name):
|
|
i += 1
|
|
|
|
# This is a simple way to stop Jedi's dynamic param recursion
|
|
# from going wild: The deeper Jedi's in the recursin, the less
|
|
# code should be evaluated.
|
|
if i * evaluator.dynamic_params_depth > MAX_PARAM_SEARCHES:
|
|
return listener.param_possibilities
|
|
|
|
for typ in evaluator.goto_definitions(name):
|
|
undecorated = undecorate(typ)
|
|
if evaluator.wrap(compare) == undecorated:
|
|
# Only if we have the correct function we execute
|
|
# it, otherwise just ignore it.
|
|
evaluator.eval_trailer([typ], trailer)
|
|
|
|
result = listener.param_possibilities
|
|
|
|
# If there are results after processing a module, we're probably
|
|
# good to process.
|
|
if result:
|
|
return result
|
|
finally:
|
|
# cleanup: remove the listener; important: should not stick.
|
|
func.listeners.remove(listener)
|
|
|
|
return set()
|