VimPlug/jedi-fork
1
0
Fork 0
forked from VimPlug/jedi
Code Pull Requests Activity

Refactor params and what execution contexts need

Browse Source
This commit is contained in:
Dave Halter
2019-09-01 14:14:42 +02:00
parent 59f26ad6ab
commit edb17b8e7c
13 changed files with 142 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
jedi/inference/param.py
View File

@@ -20,8 +20,11 @@ def _add_argument_issue(error_name, lazy_value, message):
class ExecutedParamName(ParamName):
"""Fake a param and give it values."""
def __init__(self, execution_context, param_node, lazy_value, is_default=False):
super(ExecutedParamName, self).__init__(execution_context, param_node.name)
def __init__(self, function_value, arguments, param_node, lazy_value, is_default=False):
# The arguments parameter is not needed, because it's an executed param
# name.
super(ExecutedParamName, self).__init__(
function_value, param_node.name, arguments=None)
self._lazy_value = lazy_value
self._is_default = is_default
@@ -48,13 +51,13 @@ class ExecutedParamName(ParamName):
@property
def var_args(self):
return self.parent_context.var_args
return self.arguments
def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self.string_name)
def get_executed_param_names_and_issues(execution_context, arguments):
def get_executed_param_names_and_issues(function_value, arguments):
def too_many_args(argument):
m = _error_argument_count(funcdef, len(unpacked_va))
# Just report an error for the first param that is not needed (like
@@ -74,11 +77,11 @@ def get_executed_param_names_and_issues(execution_context, arguments):
issues = [] # List[Optional[analysis issue]]
result_params = []
param_dict = {}
funcdef = execution_context.tree_node
funcdef = function_value.tree_node
# Default params are part of the value where the function was defined.
# This means that they might have access on class variables that the
# function itself doesn't have.
default_param_context = execution_context.function_value.get_default_param_context()
default_param_context = function_value.get_default_param_context()
for param in funcdef.get_params():
param_dict[param.name.value] = param
@@ -114,7 +117,8 @@ def get_executed_param_names_and_issues(execution_context, arguments):
contextualized_node.node, message=m)
)
else:
keys_used[key] = ExecutedParamName(execution_context, key_param, argument)
keys_used[key] = ExecutedParamName(
function_value, arguments, key_param, argument)
key, argument = next(var_arg_iterator, (None, None))
try:
@@ -134,13 +138,13 @@ def get_executed_param_names_and_issues(execution_context, arguments):
var_arg_iterator.push_back((key, argument))
break
lazy_value_list.append(argument)
seq = iterable.FakeTuple(execution_context.inference_state, lazy_value_list)
seq = iterable.FakeTuple(function_value.inference_state, lazy_value_list)
result_arg = LazyKnownValue(seq)
elif param.star_count == 2:
if argument is not None:
too_many_args(argument)
# **kwargs param
dct = iterable.FakeDict(execution_context.inference_state, dict(non_matching_keys))
dct = iterable.FakeDict(function_value.inference_state, dict(non_matching_keys))
result_arg = LazyKnownValue(dct)
non_matching_keys = {}
else:
@@ -167,8 +171,7 @@ def get_executed_param_names_and_issues(execution_context, arguments):
result_arg = argument
result_params.append(ExecutedParamName(
execution_context, param, result_arg,
is_default=is_default
function_value, arguments, param, result_arg, is_default=is_default
))
if not isinstance(result_arg, LazyUnknownValue):
keys_used[param.name.value] = result_params[-1]
@@ -221,22 +224,22 @@ def _error_argument_count(funcdef, actual_count):
% (funcdef.name, before, len(params), actual_count))
def _create_default_param(execution_context, param):
def _create_default_param(function_value, arguments, param):
if param.star_count == 1:
result_arg = LazyKnownValue(
iterable.FakeTuple(execution_context.inference_state, [])
iterable.FakeTuple(function_value.inference_state, [])
)
elif param.star_count == 2:
result_arg = LazyKnownValue(
iterable.FakeDict(execution_context.inference_state, {})
iterable.FakeDict(function_value.inference_state, {})
)
elif param.default is None:
result_arg = LazyUnknownValue()
else:
result_arg = LazyTreeValue(execution_context.parent_context, param.default)
return ExecutedParamName(execution_context, param, result_arg)
result_arg = LazyTreeValue(function_value.parent_context, param.default)
return ExecutedParamName(function_value, arguments, param, result_arg)
def create_default_params(execution_context, funcdef):
return [_create_default_param(execution_context, p)
def create_default_params(function_value, funcdef):
return [_create_default_param(function_value, None, p)
for p in funcdef.get_params()]