VimPlug/jedi-fork
1
0
Fork 0
forked from VimPlug/jedi
Code Pull Requests Activity

Context -> Value

Browse Source
This commit is contained in:
Dave Halter
2019-08-15 01:25:43 +02:00
parent 49f996867d
commit 9986d8c9aa
41 changed files with 536 additions and 536 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jedi/inference/gradual/annotation.py
+6 -6
View File
@@ -11,7 +11,7 @@ from parso import ParserSyntaxError, parse
from jedi._compatibility import force_unicode
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.base_value import ContextSet, NO_VALUES
from jedi.inference.base_value import ValueSet, NO_VALUES
from jedi.inference.gradual.typing import TypeVar, LazyGenericClass, \
AbstractAnnotatedClass
from jedi.inference.gradual.typing import GenericClass
@@ -112,15 +112,15 @@ def infer_param(execution_value, param):
infer_state = execution_value.infer_state
if param.star_count == 1:
tuple_ = builtin_from_name(infer_state, 'tuple')
return ContextSet([GenericClass(
return ValueSet([GenericClass(
tuple_,
generics=(values,),
) for c in values])
elif param.star_count == 2:
dct = builtin_from_name(infer_state, 'dict')
return ContextSet([GenericClass(
return ValueSet([GenericClass(
dct,
generics=(ContextSet([builtin_from_name(infer_state, 'str')]), values),
generics=(ValueSet([builtin_from_name(infer_state, 'str')]), values),
) for c in values])
pass
return values
@@ -224,9 +224,9 @@ def infer_return_types(function_execution_value):
type_var_dict = infer_type_vars_for_execution(function_execution_value, all_annotations)
return ContextSet.from_sets(
return ValueSet.from_sets(
ann.define_generics(type_var_dict)
if isinstance(ann, (AbstractAnnotatedClass, TypeVar)) else ContextSet({ann})
if isinstance(ann, (AbstractAnnotatedClass, TypeVar)) else ValueSet({ann})
for ann in annotation_values
).execute_annotation()
jedi/inference/gradual/conversion.py
+14 -14
View File
@@ -1,14 +1,14 @@
from jedi import debug
from jedi.inference.base_value import ContextSet, \
from jedi.inference.base_value import ValueSet, \
NO_VALUES
from jedi.inference.utils import to_list
from jedi.inference.gradual.stub_value import StubModuleContext
from jedi.inference.gradual.stub_value import StubModuleValue
def _stub_to_python_value_set(stub_value, ignore_compiled=False):
stub_module = stub_value.get_root_value()
if not stub_module.is_stub():
return ContextSet([stub_value])
return ValueSet([stub_value])
was_instance = stub_value.is_instance()
if was_instance:
@@ -27,7 +27,7 @@ def _stub_to_python_value_set(stub_value, ignore_compiled=False):
values = _infer_from_stub(stub_module, qualified_names, ignore_compiled)
if was_instance:
values = ContextSet.from_sets(
values = ValueSet.from_sets(
c.execute_with_values()
for c in values
if c.is_class()
@@ -41,7 +41,7 @@ def _stub_to_python_value_set(stub_value, ignore_compiled=False):
def _infer_from_stub(stub_module, qualified_names, ignore_compiled):
from jedi.inference.compiled.mixed import MixedObject
assert isinstance(stub_module, (StubModuleContext, MixedObject)), stub_module
assert isinstance(stub_module, (StubModuleValue, MixedObject)), stub_module
non_stubs = stub_module.non_stub_value_set
if ignore_compiled:
non_stubs = non_stubs.filter(lambda c: not c.is_compiled())
@@ -89,7 +89,7 @@ def _load_stub_module(module):
return _try_to_load_stub_cached(
module.infer_state,
import_names=module.string_names,
python_value_set=ContextSet([module]),
python_value_set=ValueSet([module]),
parent_module_value=None,
sys_path=module.infer_state.get_sys_path(),
)
@@ -116,7 +116,7 @@ def _python_to_stub_names(names, fallback_to_python=False):
if name_list is not None:
stub_module = _load_stub_module(module)
if stub_module is not None:
stubs = ContextSet({stub_module})
stubs = ValueSet({stub_module})
for name in name_list[:-1]:
stubs = stubs.py__getattribute__(name)
if stubs and name_list:
@@ -148,15 +148,15 @@ def convert_values(values, only_stubs=False, prefer_stubs=False, ignore_compiled
assert not (only_stubs and prefer_stubs)
with debug.increase_indent_cm('convert values'):
if only_stubs or prefer_stubs:
return ContextSet.from_sets(
return ValueSet.from_sets(
to_stub(value)
or (ContextSet({value}) if prefer_stubs else NO_VALUES)
or (ValueSet({value}) if prefer_stubs else NO_VALUES)
for value in values
)
else:
return ContextSet.from_sets(
return ValueSet.from_sets(
_stub_to_python_value_set(stub_value, ignore_compiled=ignore_compiled)
or ContextSet({stub_value})
or ValueSet({stub_value})
for stub_value in values
)
@@ -164,7 +164,7 @@ def convert_values(values, only_stubs=False, prefer_stubs=False, ignore_compiled
# TODO merge with _python_to_stub_names?
def to_stub(value):
if value.is_stub():
return ContextSet([value])
return ValueSet([value])
was_instance = value.is_instance()
if was_instance:
@@ -182,12 +182,12 @@ def to_stub(value):
qualified_names = qualified_names[:-1]
was_instance = True
stub_values = ContextSet([stub_module])
stub_values = ValueSet([stub_module])
for name in qualified_names:
stub_values = stub_values.py__getattribute__(name)
if was_instance:
stub_values = ContextSet.from_sets(
stub_values = ValueSet.from_sets(
c.execute_with_values()
for c in stub_values
if c.is_class()
jedi/inference/gradual/stub_value.py
+8 -8
View File
@@ -1,13 +1,13 @@
from jedi.inference.base_value import ContextWrapper
from jedi.inference.value.module import ModuleContext
from jedi.inference.base_value import ValueWrapper
from jedi.inference.value.module import ModuleValue
from jedi.inference.filters import ParserTreeFilter, \
TreeNameDefinition
from jedi.inference.gradual.typing import TypingModuleFilterWrapper
class StubModuleContext(ModuleContext):
class StubModuleValue(ModuleValue):
def __init__(self, non_stub_value_set, *args, **kwargs):
super(StubModuleContext, self).__init__(*args, **kwargs)
super(StubModuleValue, self).__init__(*args, **kwargs)
self.non_stub_value_set = non_stub_value_set
def is_stub(self):
@@ -27,7 +27,7 @@ class StubModuleContext(ModuleContext):
pass
else:
names.update(method())
names.update(super(StubModuleContext, self).sub_modules_dict())
names.update(super(StubModuleValue, self).sub_modules_dict())
return names
def _get_first_non_stub_filters(self):
@@ -44,7 +44,7 @@ class StubModuleContext(ModuleContext):
def get_filters(self, search_global=False, until_position=None,
origin_scope=None, **kwargs):
filters = super(StubModuleContext, self).get_filters(
filters = super(StubModuleValue, self).get_filters(
search_global, until_position, origin_scope, **kwargs
)
next(filters) # Ignore the first filter and replace it with our own
@@ -60,7 +60,7 @@ class StubModuleContext(ModuleContext):
yield f
class TypingModuleWrapper(StubModuleContext):
class TypingModuleWrapper(StubModuleValue):
def get_filters(self, *args, **kwargs):
filters = super(TypingModuleWrapper, self).get_filters(*args, **kwargs)
yield TypingModuleFilterWrapper(next(filters))
@@ -101,5 +101,5 @@ class StubFilter(ParserTreeFilter):
return True
class VersionInfo(ContextWrapper):
class VersionInfo(ValueWrapper):
pass
jedi/inference/gradual/typeshed.py
+6 -6
View File
@@ -5,8 +5,8 @@ from functools import wraps
from jedi.file_io import FileIO
from jedi._compatibility import FileNotFoundError, cast_path
from jedi.parser_utils import get_cached_code_lines
from jedi.inference.base_value import ContextSet, NO_VALUES
from jedi.inference.gradual.stub_value import TypingModuleWrapper, StubModuleContext
from jedi.inference.base_value import ValueSet, NO_VALUES
from jedi.inference.gradual.stub_value import TypingModuleWrapper, StubModuleValue
_jedi_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
TYPESHED_PATH = os.path.join(_jedi_path, 'third_party', 'typeshed')
@@ -107,7 +107,7 @@ def import_module_decorator(func):
python_parent, = infer_state.import_module(('os',), prefer_stubs=False)
python_value_set = python_parent.py__getattribute__('path')
else:
python_value_set = ContextSet.from_sets(
python_value_set = ValueSet.from_sets(
func(infer_state, import_names, p, sys_path,)
for p in parent_module_values
)
@@ -119,7 +119,7 @@ def import_module_decorator(func):
stub = _try_to_load_stub_cached(infer_state, import_names, python_value_set,
parent_module_value, sys_path)
if stub is not None:
return ContextSet([stub])
return ValueSet([stub])
return python_value_set
return wrapper
@@ -235,7 +235,7 @@ def _load_from_typeshed(infer_state, python_value_set, parent_module_value, impo
if len(import_names) == 1:
map_ = _cache_stub_file_map(infer_state.grammar.version_info)
import_name = _IMPORT_MAP.get(import_name, import_name)
elif isinstance(parent_module_value, StubModuleContext):
elif isinstance(parent_module_value, StubModuleValue):
if not parent_module_value.is_package:
# Only if it's a package (= a folder) something can be
# imported.
@@ -275,7 +275,7 @@ def create_stub_module(infer_state, python_value_set, stub_module_node, file_io,
if import_names == ('typing',):
module_cls = TypingModuleWrapper
else:
module_cls = StubModuleContext
module_cls = StubModuleValue
file_name = os.path.basename(file_io.path)
stub_module_value = module_cls(
python_value_set, infer_state, stub_module_node,
jedi/inference/gradual/typing.py
+58 -58
View File
@@ -9,15 +9,15 @@ from jedi._compatibility import unicode, force_unicode
from jedi import debug
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.compiled import builtin_from_name
from jedi.inference.base_value import ContextSet, NO_VALUES, Context, \
iterator_to_value_set, ContextWrapper, LazyContextWrapper
from jedi.inference.lazy_value import LazyKnownContexts
from jedi.inference.value.iterable import SequenceLiteralContext
from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \
iterator_to_value_set, ValueWrapper, 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.utils import to_list
from jedi.inference.filters import FilterWrapper
from jedi.inference.names import NameWrapper, AbstractTreeName, \
AbstractNameDefinition, ContextName
AbstractNameDefinition, ValueName
from jedi.inference.helpers import is_string
from jedi.inference.value.klass import ClassMixin, ClassFilter
@@ -41,12 +41,12 @@ class TypingName(AbstractTreeName):
self._value = value
def infer(self):
return ContextSet([self._value])
return ValueSet([self._value])
class _BaseTypingContext(Context):
class _BaseTypingValue(Value):
def __init__(self, infer_state, parent_value, tree_name):
super(_BaseTypingContext, self).__init__(infer_state, parent_value)
super(_BaseTypingValue, self).__init__(infer_state, parent_value)
self._tree_name = tree_name
@property
@@ -75,7 +75,7 @@ class _BaseTypingContext(Context):
@property
def name(self):
return ContextName(self, self._tree_name)
return ValueName(self, self._tree_name)
def __repr__(self):
return '%s(%s)' % (self.__class__.__name__, self._tree_name.value)
@@ -83,7 +83,7 @@ class _BaseTypingContext(Context):
class TypingModuleName(NameWrapper):
def infer(self):
return ContextSet(self._remap())
return ValueSet(self._remap())
def _remap(self):
name = self.string_name
@@ -97,9 +97,9 @@ class TypingModuleName(NameWrapper):
return
if name in _PROXY_CLASS_TYPES:
yield TypingClassContext.create_cached(infer_state, self.parent_value, self.tree_name)
yield TypingClassValue.create_cached(infer_state, self.parent_value, self.tree_name)
elif name in _PROXY_TYPES:
yield TypingContext.create_cached(infer_state, self.parent_value, self.tree_name)
yield TypingValue.create_cached(infer_state, self.parent_value, self.tree_name)
elif name == 'runtime':
# We don't want anything here, not sure what this function is
# supposed to do, since it just appears in the stubs and shouldn't
@@ -138,7 +138,7 @@ class TypingModuleFilterWrapper(FilterWrapper):
name_wrapper_class = TypingModuleName
class _WithIndexBase(_BaseTypingContext):
class _WithIndexBase(_BaseTypingValue):
def __init__(self, infer_state, parent_value, name, index_value, value_of_index):
super(_WithIndexBase, self).__init__(infer_state, parent_value, name)
self._index_value = index_value
@@ -152,28 +152,28 @@ class _WithIndexBase(_BaseTypingContext):
)
class TypingContextWithIndex(_WithIndexBase):
class TypingValueWithIndex(_WithIndexBase):
def execute_annotation(self):
string_name = self._tree_name.value
if string_name == 'Union':
# This is kind of a special case, because we have Unions (in Jedi
# ContextSets).
# ValueSets).
return self.gather_annotation_classes().execute_annotation()
elif string_name == 'Optional':
# Optional is basically just saying it's either None or the actual
# type.
return self.gather_annotation_classes().execute_annotation() \
| ContextSet([builtin_from_name(self.infer_state, u'None')])
| ValueSet([builtin_from_name(self.infer_state, u'None')])
elif string_name == 'Type':
# The type is actually already given in the index_value
return ContextSet([self._index_value])
return ValueSet([self._index_value])
elif string_name == 'ClassVar':
# For now don't do anything here, ClassVars are always used.
return self._index_value.execute_annotation()
cls = globals()[string_name]
return ContextSet([cls(
return ValueSet([cls(
self.infer_state,
self.parent_value,
self._tree_name,
@@ -182,17 +182,17 @@ class TypingContextWithIndex(_WithIndexBase):
)])
def gather_annotation_classes(self):
return ContextSet.from_sets(
return ValueSet.from_sets(
_iter_over_arguments(self._index_value, self._value_of_index)
)
class TypingContext(_BaseTypingContext):
index_class = TypingContextWithIndex
class TypingValue(_BaseTypingValue):
index_class = TypingValueWithIndex
py__simple_getitem__ = None
def py__getitem__(self, index_value_set, valueualized_node):
return ContextSet(
return ValueSet(
self.index_class.create_cached(
self.infer_state,
self.parent_value,
@@ -205,7 +205,7 @@ class TypingContext(_BaseTypingContext):
class _TypingClassMixin(object):
def py__bases__(self):
return [LazyKnownContexts(
return [LazyKnownValues(
self.infer_state.builtins_module.py__getattribute__('object')
)]
@@ -213,21 +213,21 @@ class _TypingClassMixin(object):
return []
class TypingClassContextWithIndex(_TypingClassMixin, TypingContextWithIndex, ClassMixin):
class TypingClassValueWithIndex(_TypingClassMixin, TypingValueWithIndex, ClassMixin):
pass
class TypingClassContext(_TypingClassMixin, TypingContext, ClassMixin):
index_class = TypingClassContextWithIndex
class TypingClassValue(_TypingClassMixin, TypingValue, ClassMixin):
index_class = TypingClassValueWithIndex
def _iter_over_arguments(maybe_tuple_value, defining_value):
def iterate():
if isinstance(maybe_tuple_value, SequenceLiteralContext):
if isinstance(maybe_tuple_value, SequenceLiteralValue):
for lazy_value in maybe_tuple_value.py__iter__(valueualized_node=None):
yield lazy_value.infer()
else:
yield ContextSet([maybe_tuple_value])
yield ValueSet([maybe_tuple_value])
def resolve_forward_references(value_set):
for value in value_set:
@@ -241,10 +241,10 @@ def _iter_over_arguments(maybe_tuple_value, defining_value):
yield value
for value_set in iterate():
yield ContextSet(resolve_forward_references(value_set))
yield ValueSet(resolve_forward_references(value_set))
class TypeAlias(LazyContextWrapper):
class TypeAlias(LazyValueWrapper):
def __init__(self, parent_value, origin_tree_name, actual):
self.infer_state = parent_value.infer_state
self.parent_value = parent_value
@@ -253,7 +253,7 @@ class TypeAlias(LazyContextWrapper):
@property
def name(self):
return ContextName(self, self._origin_tree_name)
return ValueName(self, self._origin_tree_name)
def py__name__(self):
return self.name.string_name
@@ -299,7 +299,7 @@ class Tuple(_ContainerBase):
def _is_homogenous(self):
# To specify a variable-length tuple of homogeneous type, Tuple[T, ...]
# is used.
if isinstance(self._index_value, SequenceLiteralContext):
if isinstance(self._index_value, SequenceLiteralValue):
entries = self._index_value.get_tree_entries()
if len(entries) == 2 and entries[1] == '...':
return True
@@ -317,17 +317,17 @@ class Tuple(_ContainerBase):
def py__iter__(self, valueualized_node=None):
if self._is_homogenous():
yield LazyKnownContexts(self._get_getitem_values(0).execute_annotation())
yield LazyKnownValues(self._get_getitem_values(0).execute_annotation())
else:
if isinstance(self._index_value, SequenceLiteralContext):
if isinstance(self._index_value, SequenceLiteralValue):
for i in range(self._index_value.py__len__()):
yield LazyKnownContexts(self._get_getitem_values(i).execute_annotation())
yield LazyKnownValues(self._get_getitem_values(i).execute_annotation())
def py__getitem__(self, index_value_set, valueualized_node):
if self._is_homogenous():
return self._get_getitem_values(0).execute_annotation()
return ContextSet.from_sets(
return ValueSet.from_sets(
_iter_over_arguments(self._index_value, self._value_of_index)
).execute_annotation()
@@ -340,13 +340,13 @@ class Protocol(_ContainerBase):
pass
class Any(_BaseTypingContext):
class Any(_BaseTypingValue):
def execute_annotation(self):
debug.warning('Used Any - returned no results')
return NO_VALUES
class TypeVarClass(_BaseTypingContext):
class TypeVarClass(_BaseTypingValue):
def py__call__(self, arguments):
unpacked = arguments.unpack()
@@ -357,7 +357,7 @@ class TypeVarClass(_BaseTypingContext):
debug.warning('Found a variable without a name %s', arguments)
return NO_VALUES
return ContextSet([TypeVar.create_cached(
return ValueSet([TypeVar.create_cached(
self.infer_state,
self.parent_value,
self._tree_name,
@@ -390,7 +390,7 @@ class TypeVarClass(_BaseTypingContext):
return None
class TypeVar(_BaseTypingContext):
class TypeVar(_BaseTypingValue):
def __init__(self, infer_state, parent_value, tree_name, var_name, unpacked_args):
super(TypeVar, self).__init__(infer_state, parent_value, tree_name)
self._var_name = var_name
@@ -432,7 +432,7 @@ class TypeVar(_BaseTypingContext):
@property
def constraints(self):
return ContextSet.from_sets(
return ValueSet.from_sets(
lazy.infer() for lazy in self._constraints_lazy_values
)
@@ -444,7 +444,7 @@ class TypeVar(_BaseTypingContext):
else:
if found:
return found
return self._get_classes() or ContextSet({self})
return self._get_classes() or ValueSet({self})
def execute_annotation(self):
return self._get_classes().execute_annotation()
@@ -453,21 +453,21 @@ class TypeVar(_BaseTypingContext):
return '<%s: %s>' % (self.__class__.__name__, self.py__name__())
class OverloadFunction(_BaseTypingContext):
class OverloadFunction(_BaseTypingValue):
@repack_with_argument_clinic('func, /')
def py__call__(self, func_value_set):
# Just pass arguments through.
return func_value_set
class NewTypeFunction(_BaseTypingContext):
class NewTypeFunction(_BaseTypingValue):
def py__call__(self, arguments):
ordered_args = arguments.unpack()
next(ordered_args, (None, None))
_, second_arg = next(ordered_args, (None, None))
if second_arg is None:
return NO_VALUES
return ContextSet(
return ValueSet(
NewType(
self.infer_state,
valueualized_node.value,
@@ -476,7 +476,7 @@ class NewTypeFunction(_BaseTypingContext):
) for valueualized_node in arguments.get_calling_nodes())
class NewType(Context):
class NewType(Value):
def __init__(self, infer_state, parent_value, tree_node, type_value_set):
super(NewType, self).__init__(infer_state, parent_value)
self._type_value_set = type_value_set
@@ -486,7 +486,7 @@ class NewType(Context):
return self._type_value_set.execute_annotation()
class CastFunction(_BaseTypingContext):
class CastFunction(_BaseTypingValue):
@repack_with_argument_clinic('type, object, /')
def py__call__(self, type_value_set, object_value_set):
return type_value_set.execute_annotation()
@@ -510,7 +510,7 @@ class BoundTypeVarName(AbstractNameDefinition):
yield constraint
else:
yield value
return ContextSet(iter_())
return ValueSet(iter_())
def py__name__(self):
return self._type_var.py__name__()
@@ -549,7 +549,7 @@ class TypeVarFilter(object):
return []
class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
class AbstractAnnotatedClass(ClassMixin, ValueWrapper):
def get_type_var_filter(self):
return TypeVarFilter(self.get_generics(), self.list_type_vars())
@@ -593,7 +593,7 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
def py__call__(self, arguments):
instance, = super(AbstractAnnotatedClass, self).py__call__(arguments)
return ContextSet([InstanceWrapper(instance)])
return ValueSet([InstanceWrapper(instance)])
def get_generics(self):
raise NotImplementedError
@@ -607,19 +607,19 @@ class AbstractAnnotatedClass(ClassMixin, ContextWrapper):
if isinstance(generic, (AbstractAnnotatedClass, TypeVar)):
result = generic.define_generics(type_var_dict)
values |= result
if result != ContextSet({generic}):
if result != ValueSet({generic}):
changed = True
else:
values |= ContextSet([generic])
values |= ValueSet([generic])
new_generics.append(values)
if not changed:
# There might not be any type vars that change. In that case just
# return itself, because it does not make sense to potentially lose
# cached results.
return ContextSet([self])
return ValueSet([self])
return ContextSet([GenericClass(
return ValueSet([GenericClass(
self._wrapped_value,
generics=tuple(new_generics)
)])
@@ -682,18 +682,18 @@ class LazyAnnotatedBaseClass(object):
for type_var in type_var_set:
if isinstance(type_var, TypeVar):
names = filter.get(type_var.py__name__())
new |= ContextSet.from_sets(
new |= ValueSet.from_sets(
name.infer() for name in names
)
else:
# Mostly will be type vars, except if in some cases
# a concrete type will already be there. In that
# case just add it to the value set.
new |= ContextSet([type_var])
new |= ValueSet([type_var])
yield new
class InstanceWrapper(ContextWrapper):
class InstanceWrapper(ValueWrapper):
def py__stop_iteration_returns(self):
for cls in self._wrapped_value.class_value.py__mro__():
if cls.py__name__() == 'Generator':
@@ -703,5 +703,5 @@ class InstanceWrapper(ContextWrapper):
except IndexError:
pass
elif cls.py__name__() == 'Iterator':
return ContextSet([builtin_from_name(self.infer_state, u'None')])
return ValueSet([builtin_from_name(self.infer_state, u'None')])
return self._wrapped_value.py__stop_iteration_returns()