VimPlug/jedi
1
0
Fork 1
mirror of https://github.com/davidhalter/jedi.git synced 2025-12-07 14:34:31 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Create separate classes for FakeSequence

Browse Source
This commit is contained in:
Dave Halter
2019-08-25 14:31:15 +02:00
parent 51912db46a
commit 473dbb0f69
5 changed files with 28 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
jedi/inference/arguments.py
View File

@@ -84,7 +84,7 @@ def _iterate_argument_clinic(inference_state, arguments, parameters):
break break
lazy_values.append(argument) lazy_values.append(argument)
yield ValueSet([iterable.FakeSequence(inference_state, u'tuple', lazy_values)]) yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)])
lazy_values lazy_values
continue continue
elif stars == 2: elif stars == 2:

7
jedi/inference/docstrings.py
View File

@@ -253,8 +253,8 @@ def _execute_array_values(inference_state, array):
Tuples indicate that there's not just one return value, but the listed 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. ones. `(str, int)` means that it returns a tuple with both types.
""" """
from jedi.inference.value.iterable import SequenceLiteralValue, FakeSequence from jedi.inference.value.iterable import SequenceLiteralValue, FakeTuple, FakeList
if isinstance(array, SequenceLiteralValue): if isinstance(array, SequenceLiteralValue) and array.array_type in ('tuple', 'list'):
values = [] values = []
for lazy_value in array.py__iter__(): for lazy_value in array.py__iter__():
objects = ValueSet.from_sets( objects = ValueSet.from_sets(
@@ -262,7 +262,8 @@ def _execute_array_values(inference_state, array):
for typ in lazy_value.infer() for typ in lazy_value.infer()
) )
values.append(LazyKnownValues(objects)) 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: else:
return array.execute_annotation() return array.execute_annotation()

4
jedi/inference/param.py
View File

@@ -134,7 +134,7 @@ def get_executed_param_names_and_issues(execution_context, arguments):
var_arg_iterator.push_back((key, argument)) var_arg_iterator.push_back((key, argument))
break break
lazy_value_list.append(argument) 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) result_arg = LazyKnownValue(seq)
elif param.star_count == 2: elif param.star_count == 2:
if argument is not None: if argument is not None:
@@ -224,7 +224,7 @@ def _error_argument_count(funcdef, actual_count):
def _create_default_param(execution_context, param): def _create_default_param(execution_context, param):
if param.star_count == 1: if param.star_count == 1:
result_arg = LazyKnownValue( result_arg = LazyKnownValue(
iterable.FakeSequence(execution_context.inference_state, u'tuple', []) iterable.FakeTuple(execution_context.inference_state, [])
) )
elif param.star_count == 2: elif param.star_count == 2:
result_arg = LazyKnownValue( result_arg = LazyKnownValue(

34
jedi/inference/value/iterable.py
View File

@@ -298,15 +298,14 @@ class DictComprehension(ComprehensionMixin, Sequence):
@publish_method('values') @publish_method('values')
def _imitate_values(self): def _imitate_values(self):
lazy_value = LazyKnownValues(self._dict_values()) 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') @publish_method('items')
def _imitate_items(self): def _imitate_items(self):
lazy_values = [ lazy_values = [
LazyKnownValue( LazyKnownValue(
FakeSequence( FakeTuple(
self.inference_state, self.inference_state,
u'tuple',
[LazyKnownValues(key), [LazyKnownValues(key),
LazyKnownValues(value)] LazyKnownValues(value)]
) )
@@ -314,7 +313,7 @@ class DictComprehension(ComprehensionMixin, Sequence):
for key, value in self._iterate() 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): def get_mapping_item_values(self):
return self._dict_keys(), self._dict_values() return self._dict_keys(), self._dict_values()
@@ -469,19 +468,19 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue):
@publish_method('values') @publish_method('values')
def _imitate_values(self): def _imitate_values(self):
lazy_value = LazyKnownValues(self._dict_values()) 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') @publish_method('items')
def _imitate_items(self): def _imitate_items(self):
lazy_values = [ lazy_values = [
LazyKnownValue(FakeSequence( LazyKnownValue(FakeTuple(
self.inference_state, u'tuple', self.inference_state,
(LazyTreeValue(self._defining_context, key_node), (LazyTreeValue(self._defining_context, key_node),
LazyTreeValue(self._defining_context, value_node)) LazyTreeValue(self._defining_context, value_node))
)) for key_node, value_node in self.get_tree_entries() )) 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): def _dict_keys(self):
return ValueSet.from_sets( return ValueSet.from_sets(
@@ -493,14 +492,13 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue):
return self._dict_keys(), self._dict_values() return self._dict_keys(), self._dict_values()
class FakeSequence(Sequence): class _FakeSequence(Sequence):
def __init__(self, inference_state, array_type, lazy_value_list): def __init__(self, inference_state, lazy_value_list):
""" """
type should be one of "tuple", "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._lazy_value_list = lazy_value_list
self.array_type = array_type
def py__simple_getitem__(self, index): def py__simple_getitem__(self, index):
if isinstance(index, slice): if isinstance(index, slice):
@@ -520,6 +518,14 @@ class FakeSequence(Sequence):
return "<%s of %s>" % (type(self).__name__, self._lazy_value_list) 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): class FakeDict(_DictMixin, Sequence):
array_type = u'dict' array_type = u'dict'
@@ -553,8 +559,8 @@ class FakeDict(_DictMixin, Sequence):
@publish_method('values') @publish_method('values')
def _values(self): def _values(self):
return ValueSet([FakeSequence( return ValueSet([FakeTuple(
self.inference_state, u'tuple', self.inference_state,
[LazyKnownValues(self._dict_values())] [LazyKnownValues(self._dict_values())]
)]) )])

3
jedi/plugins/stdlib.py
View File

@@ -643,9 +643,8 @@ class ItemGetterCallable(ValueWrapper):
# TODO we need to add the contextualized value. # TODO we need to add the contextualized value.
value_set |= item_value_set.get_item(lazy_values[0].infer(), None) value_set |= item_value_set.get_item(lazy_values[0].infer(), None)
else: else:
value_set |= ValueSet([iterable.FakeSequence( value_set |= ValueSet([iterable.FakeList(
self._wrapped_value.inference_state, self._wrapped_value.inference_state,
'list',
[ [
LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None)) LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None))
for lazy_value in lazy_values for lazy_value in lazy_values