From 473dbb0f690aa740e5132141b4bb78bb4b0942b0 Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Sun, 25 Aug 2019 14:31:15 +0200 Subject: [PATCH] Create separate classes for FakeSequence --- jedi/inference/arguments.py | 2 +- jedi/inference/docstrings.py | 7 ++++--- jedi/inference/param.py | 4 ++-- jedi/inference/value/iterable.py | 34 +++++++++++++++++++------------- jedi/plugins/stdlib.py | 3 +-- 5 files changed, 28 insertions(+), 22 deletions(-) diff --git a/jedi/inference/arguments.py b/jedi/inference/arguments.py index e5497553..b0ff8e14 100644 --- a/jedi/inference/arguments.py +++ b/jedi/inference/arguments.py @@ -84,7 +84,7 @@ def _iterate_argument_clinic(inference_state, arguments, parameters): break lazy_values.append(argument) - yield ValueSet([iterable.FakeSequence(inference_state, u'tuple', lazy_values)]) + yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)]) lazy_values continue elif stars == 2: diff --git a/jedi/inference/docstrings.py b/jedi/inference/docstrings.py index 46900475..4bee75eb 100644 --- a/jedi/inference/docstrings.py +++ b/jedi/inference/docstrings.py @@ -253,8 +253,8 @@ def _execute_array_values(inference_state, array): Tuples indicate that there's not just one return value, but the listed ones. `(str, int)` means that it returns a tuple with both types. """ - from jedi.inference.value.iterable import SequenceLiteralValue, FakeSequence - if isinstance(array, SequenceLiteralValue): + from jedi.inference.value.iterable import SequenceLiteralValue, FakeTuple, FakeList + if isinstance(array, SequenceLiteralValue) and array.array_type in ('tuple', 'list'): values = [] for lazy_value in array.py__iter__(): objects = ValueSet.from_sets( @@ -262,7 +262,8 @@ def _execute_array_values(inference_state, array): for typ in lazy_value.infer() ) values.append(LazyKnownValues(objects)) - return {FakeSequence(inference_state, array.array_type, values)} + cls = FakeTuple if array.array_type == 'tuple' else FakeList + return {cls(inference_state, values)} else: return array.execute_annotation() diff --git a/jedi/inference/param.py b/jedi/inference/param.py index c32297cc..09e450ab 100644 --- a/jedi/inference/param.py +++ b/jedi/inference/param.py @@ -134,7 +134,7 @@ 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.FakeSequence(execution_context.inference_state, u'tuple', lazy_value_list) + seq = iterable.FakeTuple(execution_context.inference_state, lazy_value_list) result_arg = LazyKnownValue(seq) elif param.star_count == 2: if argument is not None: @@ -224,7 +224,7 @@ def _error_argument_count(funcdef, actual_count): def _create_default_param(execution_context, param): if param.star_count == 1: result_arg = LazyKnownValue( - iterable.FakeSequence(execution_context.inference_state, u'tuple', []) + iterable.FakeTuple(execution_context.inference_state, []) ) elif param.star_count == 2: result_arg = LazyKnownValue( diff --git a/jedi/inference/value/iterable.py b/jedi/inference/value/iterable.py index 2b676dad..844748b0 100644 --- a/jedi/inference/value/iterable.py +++ b/jedi/inference/value/iterable.py @@ -298,15 +298,14 @@ class DictComprehension(ComprehensionMixin, Sequence): @publish_method('values') def _imitate_values(self): lazy_value = LazyKnownValues(self._dict_values()) - return ValueSet([FakeSequence(self.inference_state, u'list', [lazy_value])]) + return ValueSet([FakeList(self.inference_state, [lazy_value])]) @publish_method('items') def _imitate_items(self): lazy_values = [ LazyKnownValue( - FakeSequence( + FakeTuple( self.inference_state, - u'tuple', [LazyKnownValues(key), LazyKnownValues(value)] ) @@ -314,7 +313,7 @@ class DictComprehension(ComprehensionMixin, Sequence): for key, value in self._iterate() ] - return ValueSet([FakeSequence(self.inference_state, u'list', lazy_values)]) + return ValueSet([FakeList(self.inference_state, lazy_values)]) def get_mapping_item_values(self): return self._dict_keys(), self._dict_values() @@ -469,19 +468,19 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue): @publish_method('values') def _imitate_values(self): lazy_value = LazyKnownValues(self._dict_values()) - return ValueSet([FakeSequence(self.inference_state, u'list', [lazy_value])]) + return ValueSet([FakeList(self.inference_state, [lazy_value])]) @publish_method('items') def _imitate_items(self): lazy_values = [ - LazyKnownValue(FakeSequence( - self.inference_state, u'tuple', + LazyKnownValue(FakeTuple( + self.inference_state, (LazyTreeValue(self._defining_context, key_node), LazyTreeValue(self._defining_context, value_node)) )) for key_node, value_node in self.get_tree_entries() ] - return ValueSet([FakeSequence(self.inference_state, u'list', lazy_values)]) + return ValueSet([FakeList(self.inference_state, lazy_values)]) def _dict_keys(self): return ValueSet.from_sets( @@ -493,14 +492,13 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue): return self._dict_keys(), self._dict_values() -class FakeSequence(Sequence): - def __init__(self, inference_state, array_type, lazy_value_list): +class _FakeSequence(Sequence): + def __init__(self, inference_state, lazy_value_list): """ type should be one of "tuple", "list" """ - super(FakeSequence, self).__init__(inference_state) + super(_FakeSequence, self).__init__(inference_state) self._lazy_value_list = lazy_value_list - self.array_type = array_type def py__simple_getitem__(self, index): if isinstance(index, slice): @@ -520,6 +518,14 @@ class FakeSequence(Sequence): return "<%s of %s>" % (type(self).__name__, self._lazy_value_list) +class FakeTuple(_FakeSequence): + array_type = u'tuple' + + +class FakeList(_FakeSequence): + array_type = u'tuple' + + class FakeDict(_DictMixin, Sequence): array_type = u'dict' @@ -553,8 +559,8 @@ class FakeDict(_DictMixin, Sequence): @publish_method('values') def _values(self): - return ValueSet([FakeSequence( - self.inference_state, u'tuple', + return ValueSet([FakeTuple( + self.inference_state, [LazyKnownValues(self._dict_values())] )]) diff --git a/jedi/plugins/stdlib.py b/jedi/plugins/stdlib.py index fdf7bb25..eca602bc 100644 --- a/jedi/plugins/stdlib.py +++ b/jedi/plugins/stdlib.py @@ -643,9 +643,8 @@ class ItemGetterCallable(ValueWrapper): # TODO we need to add the contextualized value. value_set |= item_value_set.get_item(lazy_values[0].infer(), None) else: - value_set |= ValueSet([iterable.FakeSequence( + value_set |= ValueSet([iterable.FakeList( self._wrapped_value.inference_state, - 'list', [ LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None)) for lazy_value in lazy_values