From c8b7d79b54231d2f42025971622175065b63ba06 Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Sat, 7 Jun 2014 13:10:19 +0200 Subject: [PATCH] erroneus star arguments warning --- jedi/evaluate/analysis.py | 3 ++- jedi/evaluate/param.py | 31 ++++++++++++++++---------- test/static_analysis/star_arguments.py | 5 ++++- 3 files changed, 25 insertions(+), 14 deletions(-) diff --git a/jedi/evaluate/analysis.py b/jedi/evaluate/analysis.py index 0c2d54e6..2c83bedc 100644 --- a/jedi/evaluate/analysis.py +++ b/jedi/evaluate/analysis.py @@ -16,7 +16,8 @@ CODES = { 'type-error-too-few-arguments': (6, TypeError, None), 'type-error-keyword-argument': (7, TypeError, None), 'type-error-multiple-values': (8, TypeError, None), - 'type-error-star-star-mapping': (9, TypeError, None), + 'type-error-star-star': (9, TypeError, None), + 'type-error-star': (9, TypeError, None), } diff --git a/jedi/evaluate/param.py b/jedi/evaluate/param.py index d25a08d4..4b5eda37 100644 --- a/jedi/evaluate/param.py +++ b/jedi/evaluate/param.py @@ -75,7 +75,7 @@ def get_params(evaluator, func, var_args): 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. - va = _unpack_var_args(evaluator, var_args, func.params) + va = _unpack_var_args(evaluator, var_args, func) var_arg_iterator = common.PushBackIterator(iter(va)) non_matching_keys = [] @@ -196,7 +196,7 @@ def get_params(evaluator, func, var_args): return result -def _unpack_var_args(evaluator, var_args, params): +def _unpack_var_args(evaluator, var_args, func): """ Yields a key/value pair, the key is None, if its not a named arg. """ @@ -218,7 +218,8 @@ def _unpack_var_args(evaluator, var_args, params): # *args if expression_list[0] == '*': arrays = evaluator.eval_expression_list(expression_list[1:]) - iterators = [_iterate_star_args(a) for a in arrays] + iterators = [_iterate_star_args(evaluator, a, expression_list[1:], func) + for a in arrays] for values in list(zip_longest(*iterators)): argument_list.append((None, [v for v in values if v is not None])) # **kwargs @@ -227,7 +228,7 @@ def _unpack_var_args(evaluator, var_args, params): for array in evaluator.eval_expression_list(expression_list[1:]): # Merge multiple kwargs dictionaries, if used with dynamic # parameters. - s = _star_star_dict(evaluator, array, expression_list[1:]) + s = _star_star_dict(evaluator, array, expression_list[1:], func) for name, (key, value) in s.items(): try: dct[name][1].add(value) @@ -236,7 +237,7 @@ def _unpack_var_args(evaluator, var_args, params): for key, values in dct.values(): # merge **kwargs/*args also for dynamic parameters - for i, p in enumerate(params): + for i, p in enumerate(func.params): if str(p.get_name()) == str(key) and not p.stars: try: k, vs = argument_list[i] @@ -264,19 +265,25 @@ def _unpack_var_args(evaluator, var_args, params): return argument_list -def _iterate_star_args(array): +def _iterate_star_args(evaluator, array, expression_list, func): + from jedi.evaluate.representation import Instance if isinstance(array, iterable.Array): for field_stmt in array: # yield from plz! yield field_stmt elif isinstance(array, iterable.Generator): for field_stmt in array.iter_content(): yield helpers.FakeStatement([field_stmt]) + elif isinstance(array, Instance) and array.name == 'tuple': + pass else: - # *args must be some sort of an array, otherwise -> ignore - pass # TODO need a warning here. + if expression_list: + m = "TypeError: %s() argument after * must be a sequence, not %s" \ + % (func.name, array) + analysis.add(evaluator, 'type-error-star', + expression_list[0], message=m) -def _star_star_dict(evaluator, array, expression_list): +def _star_star_dict(evaluator, array, expression_list, func): dct = {} if isinstance(array, iterable.Array) and array.type == pr.Array.DICT: for key_stmt, value_stmt in array.items(): @@ -294,9 +301,9 @@ def _star_star_dict(evaluator, array, expression_list): dct[str(key)] = key, value_stmt else: if expression_list: - m = "TypeError: type object argument after ** must be a mapping, not %s" \ - % (array) - analysis.add(evaluator, 'type-error-star-star-mapping', + m = "TypeError: %s argument after ** must be a mapping, not %s" \ + % (func.name, array) + analysis.add(evaluator, 'type-error-star-star', expression_list[0], message=m) return dct diff --git a/test/static_analysis/star_arguments.py b/test/static_analysis/star_arguments.py index 34a27d0e..dc991036 100644 --- a/test/static_analysis/star_arguments.py +++ b/test/static_analysis/star_arguments.py @@ -100,5 +100,8 @@ mixed2(3, b=5) # plain wrong arguments # ----------------- -#! 12 type-error-star-star-mapping +#! 12 type-error-star-star simple(1, **[]) + +#! 11 type-error-star +simple(1, *1)