From 8a9453872fec72db066782a100f77f9fffd18936 Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Tue, 7 Jan 2014 14:44:39 +0100 Subject: [PATCH] cleaned up evaluate.param --- jedi/evaluate/param.py | 122 +++++++++++++++++++---------------------- 1 file changed, 56 insertions(+), 66 deletions(-) diff --git a/jedi/evaluate/param.py b/jedi/evaluate/param.py index fafb223a..449aa513 100644 --- a/jedi/evaluate/param.py +++ b/jedi/evaluate/param.py @@ -53,9 +53,8 @@ def get_params(evaluator, func, var_args): param_dict = {} for param in func.params: param_dict[str(param.get_name())] = param - # There may be calls, which don't fit all the params, this just ignores - # it. - var_arg_iterator = _get_var_args_iterator(evaluator, var_args) + # There may be calls, which don't fit all the params, this just ignores it. + var_arg_iterator = common.PushBackIterator(_var_args_iterator(evaluator, var_args)) non_matching_keys = [] keys_used = set() @@ -63,9 +62,8 @@ def get_params(evaluator, func, var_args): for param in func.params[start_offset:]: # The value and key can both be null. There, the defaults apply. # args / kwargs will just be empty arrays / dicts, respectively. - # Wrong value count is just ignored. If you try to test cases that - # are not allowed in Python, Jedi will maybe not show any - # completions. + # Wrong value count is just ignored. If you try to test cases that are + # not allowed in Python, Jedi will maybe not show any completions. key, value = next(var_arg_iterator, (None, None)) while key: keys_only = True @@ -75,8 +73,7 @@ def get_params(evaluator, func, var_args): non_matching_keys.append((key, value)) else: keys_used.add(str(key)) - result.append(gen_param_name_copy(key_param, - values=[value])) + result.append(gen_param_name_copy(key_param, values=[value])) key, value = next(var_arg_iterator, (None, None)) expression_list = param.expression_list() @@ -111,17 +108,17 @@ def get_params(evaluator, func, var_args): result.append(param.get_name()) param.is_generated = True else: - # If there is no assignment detail, that means there is - # no assignment, just the result. Therefore nothing has - # to be returned. + # If there is no assignment detail, that means there is no + # assignment, just the result. Therefore nothing has to be + # returned. values = [] - # Just ignore all the params that are without a key, after one - # keyword argument was set. + # Just ignore all the params that are without a key, after one keyword + # argument was set. if not ignore_creation and (not keys_only or expression_list[0] == '**'): keys_used.add(str(key)) - result.append(gen_param_name_copy(param, keys=keys, - values=values, array_type=array_type)) + result.append(gen_param_name_copy(param, keys=keys, values=values, + array_type=array_type)) if keys_only: # sometimes param arguments are not completely written (which would @@ -131,61 +128,55 @@ def get_params(evaluator, func, var_args): return result -def _get_var_args_iterator(evaluator, var_args): +def _var_args_iterator(evaluator, var_args): """ Yields a key/value pair, the key is None, if its not a named arg. """ - def iterate(): - # `var_args` is typically an Array, and not a list. - for stmt in var_args: - if not isinstance(stmt, pr.Statement): - if stmt is None: - yield None, None - continue - old = stmt - # generate a statement if it's not already one. - module = builtin.Builtin.scope - stmt = pr.Statement(module, [], (0, 0), None) - stmt._expression_list = [old] - - # *args - expression_list = stmt.expression_list() - if not len(expression_list): + # `var_args` is typically an Array, and not a list. + for stmt in var_args: + if not isinstance(stmt, pr.Statement): + if stmt is None: + yield None, None continue - if expression_list[0] == '*': - arrays = evaluator.eval_expression_list(expression_list[1:]) - # *args must be some sort of an array, otherwise -> ignore + old = stmt + # generate a statement if it's not already one. + module = builtin.Builtin.scope + stmt = pr.Statement(module, [], (0, 0), None) + stmt._expression_list = [old] - for array in arrays: - if isinstance(array, iterable.Array): - for field_stmt in array: # yield from plz! - yield None, field_stmt - elif isinstance(array, iterable.Generator): - for field_stmt in array.iter_content(): - yield None, _FakeStatement(field_stmt) - # **kwargs - elif expression_list[0] == '**': - arrays = evaluator.eval_expression_list(expression_list[1:]) - for array in arrays: - if isinstance(array, iterable.Array): - for key_stmt, value_stmt in array.items(): - # first index, is the key if syntactically correct - call = key_stmt.expression_list()[0] - if isinstance(call, pr.Name): - yield call, value_stmt - elif isinstance(call, pr.Call): - yield call.name, value_stmt - # Normal arguments (including key arguments). + # *args + expression_list = stmt.expression_list() + if not len(expression_list): + continue + if expression_list[0] == '*': + # *args must be some sort of an array, otherwise -> ignore + for array in evaluator.eval_expression_list(expression_list[1:]): + if isinstance(array, iterable.Array): + for field_stmt in array: # yield from plz! + yield None, field_stmt + elif isinstance(array, iterable.Generator): + for field_stmt in array.iter_content(): + yield None, _FakeStatement(field_stmt) + # **kwargs + elif expression_list[0] == '**': + for array in evaluator.eval_expression_list(expression_list[1:]): + if isinstance(array, iterable.Array): + for key_stmt, value_stmt in array.items(): + # first index, is the key if syntactically correct + call = key_stmt.expression_list()[0] + if isinstance(call, pr.Name): + yield call, value_stmt + elif isinstance(call, pr.Call): + yield call.name, value_stmt + # Normal arguments (including key arguments). + else: + if stmt.assignment_details: + key_arr, op = stmt.assignment_details[0] + # named parameter + if key_arr and isinstance(key_arr[0], pr.Call): + yield key_arr[0].name, stmt else: - if stmt.assignment_details: - key_arr, op = stmt.assignment_details[0] - # named parameter - if key_arr and isinstance(key_arr[0], pr.Call): - yield key_arr[0].name, stmt - else: - yield None, stmt - - return iter(common.PushBackIterator(iterate())) + yield None, stmt class _FakeSubModule(): @@ -194,6 +185,5 @@ class _FakeSubModule(): class _FakeStatement(pr.Statement): def __init__(self, content): - cls = type(self) p = 0, 0 - super(cls, self).__init__(_FakeSubModule, [content], p, p) + super(_FakeStatement, self).__init__(_FakeSubModule, [content], p, p)