From ad92882c48b2013c964eb6c6fac44e7ab949a36d Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Sun, 8 Dec 2019 22:42:01 +0100 Subject: [PATCH] Use the generics manager for all the typing classes --- jedi/inference/gradual/generics.py | 27 +++++-------- jedi/inference/gradual/typing.py | 61 ++++++++++++------------------ 2 files changed, 34 insertions(+), 54 deletions(-) diff --git a/jedi/inference/gradual/generics.py b/jedi/inference/gradual/generics.py index 45485af8..b064b60a 100644 --- a/jedi/inference/gradual/generics.py +++ b/jedi/inference/gradual/generics.py @@ -10,18 +10,6 @@ from jedi.inference.value.iterable import SequenceLiteralValue from jedi.inference.helpers import is_string -def iter_over_arguments(maybe_tuple_value, defining_context): - def iterate(): - if isinstance(maybe_tuple_value, SequenceLiteralValue): - for lazy_value in maybe_tuple_value.py__iter__(contextualized_node=None): - yield lazy_value.infer() - else: - yield ValueSet([maybe_tuple_value]) - - for value_set in iterate(): - yield ValueSet(_resolve_forward_references(defining_context, value_set)) - - def _resolve_forward_references(context, value_set): for value in value_set: if is_string(value): @@ -69,8 +57,12 @@ class LazyGenericManager(object): for callable_ in self._tuple(): yield callable_() - #def __iter__(self): - # return iter(self._iterate()) + def is_homogenous_tuple(self): + if isinstance(self._index_value, SequenceLiteralValue): + entries = self._index_value.get_tree_entries() + if len(entries) == 2 and entries[1] == '...': + return True + return False class TupleGenericManager(object): @@ -83,9 +75,8 @@ class TupleGenericManager(object): def __len__(self): return len(self._tuple) - #def __iter__(self): - # for value_set in self._tuple: - # yield lambda: value_set - def to_tuple(self): return self._tuple + + def is_homogenous_tuple(self): + return False diff --git a/jedi/inference/gradual/typing.py b/jedi/inference/gradual/typing.py index a586e86b..8a156c3d 100644 --- a/jedi/inference/gradual/typing.py +++ b/jedi/inference/gradual/typing.py @@ -11,14 +11,13 @@ from jedi.inference.compiled import builtin_from_name from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \ LazyValueWrapper from jedi.inference.lazy_value import LazyKnownValues -from jedi.inference.value.iterable import SequenceLiteralValue from jedi.inference.arguments import repack_with_argument_clinic from jedi.inference.filters import FilterWrapper from jedi.inference.names import NameWrapper, ValueName from jedi.inference.value.klass import ClassMixin from jedi.inference.gradual.base import BaseTypingValue from jedi.inference.gradual.type_var import TypeVarClass -from jedi.inference.gradual.generics import iter_over_arguments +from jedi.inference.gradual.generics import LazyGenericManager _PROXY_CLASS_TYPES = 'Tuple Generic Protocol Callable Type'.split() _TYPE_ALIAS_TYPES = { @@ -99,16 +98,15 @@ class TypingModuleFilterWrapper(FilterWrapper): class _WithIndexBase(BaseTypingValue): - def __init__(self, inference_state, parent_context, name, index_value, context_of_index): + def __init__(self, inference_state, parent_context, name, generics_manager): super(_WithIndexBase, self).__init__(inference_state, parent_context, name) - self._index_value = index_value - self._context_of_index = context_of_index + self._generics_manager = generics_manager def __repr__(self): return '<%s: %s[%s]>' % ( self.__class__.__name__, self._tree_name.value, - self._index_value, + self._generics_manager, ) @@ -127,24 +125,21 @@ class TypingValueWithIndex(_WithIndexBase): | ValueSet([builtin_from_name(self.inference_state, u'None')]) elif string_name == 'Type': # The type is actually already given in the index_value - return ValueSet([self._index_value]) + return self._generics_manager[0] elif string_name == 'ClassVar': # For now don't do anything here, ClassVars are always used. - return self._index_value.execute_annotation() + return self._generics_manager[0].execute_annotation() cls = globals()[string_name] return ValueSet([cls( self.inference_state, self.parent_context, self._tree_name, - self._index_value, - self._context_of_index + generics_manager=self._generics_manager, )]) def gather_annotation_classes(self): - return ValueSet.from_sets( - iter_over_arguments(self._index_value, self._context_of_index) - ) + return ValueSet.from_sets(self._generics_manager.to_tuple()) class ProxyTypingValue(BaseTypingValue): @@ -157,9 +152,11 @@ class ProxyTypingValue(BaseTypingValue): self.inference_state, self.parent_context, self._tree_name, - index_value, - context_of_index=contextualized_node.context) - for index_value in index_value_set + generics_manager=LazyGenericManager( + context_of_index=contextualized_node.context, + index_value=index_value, + ) + ) for index_value in index_value_set ) @@ -181,7 +178,7 @@ class TypingClassValueWithIndex(_TypingClassMixin, TypingValueWithIndex): @inference_state_method_cache() def get_generics(self): - return list(iter_over_arguments(self._index_value, self._context_of_index)) + return self._generics_manager.to_tuple() class ProxyTypingClassValue(_TypingClassMixin, ProxyTypingValue): @@ -224,13 +221,11 @@ class TypeAlias(LazyValueWrapper): class _GetItemMixin(object): def _get_getitem_values(self, index): - args = iter_over_arguments(self._index_value, self._context_of_index) - for i, values in enumerate(args): - if i == index: - return values - - debug.warning('No param #%s found for annotation %s', index, self._index_value) - return NO_VALUES + try: + return self._generics_manager[index] + except IndexError: + debug.warning('No param #%s found for annotation %s', index, self._generics_manager) + return NO_VALUES class Callable(_WithIndexBase, _GetItemMixin): @@ -240,20 +235,15 @@ class Callable(_WithIndexBase, _GetItemMixin): class Tuple(LazyValueWrapper, _GetItemMixin): - def __init__(self, inference_state, parent_context, name, index_value, context_of_index): + def __init__(self, inference_state, parent_context, name, generics_manager): self.inference_state = inference_state self.parent_context = parent_context - self._index_value = index_value - self._context_of_index = context_of_index + self._generics_manager = generics_manager def _is_homogenous(self): # To specify a variable-length tuple of homogeneous type, Tuple[T, ...] # is used. - if isinstance(self._index_value, SequenceLiteralValue): - entries = self._index_value.get_tree_entries() - if len(entries) == 2 and entries[1] == '...': - return True - return False + return self._generics_manager.is_homogenous_tuple() def py__simple_getitem__(self, index): if self._is_homogenous(): @@ -269,16 +259,15 @@ class Tuple(LazyValueWrapper, _GetItemMixin): if self._is_homogenous(): yield LazyKnownValues(self._get_getitem_values(0).execute_annotation()) else: - if isinstance(self._index_value, SequenceLiteralValue): - for i in range(self._index_value.py__len__()): - yield LazyKnownValues(self._get_getitem_values(i).execute_annotation()) + for v in self._generics_manager.to_tuple(): + yield LazyKnownValues(v.execute_annotation()) def py__getitem__(self, index_value_set, contextualized_node): if self._is_homogenous(): return self._get_getitem_values(0).execute_annotation() return ValueSet.from_sets( - iter_over_arguments(self._index_value, self._context_of_index) + self._generics_manager.to_tuple() ).execute_annotation() def _get_wrapped_value(self):