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

10
jedi/inference/value/__init__.py
View File

@@ -1,6 +1,6 @@
from jedi.inference.value.module import ModuleContext
from jedi.inference.value.klass import ClassContext
from jedi.inference.value.function import FunctionContext, \
MethodContext, FunctionExecutionContext
from jedi.inference.value.module import ModuleValue
from jedi.inference.value.klass import ClassValue
from jedi.inference.value.function import FunctionValue, \
MethodValue, FunctionExecutionValue
from jedi.inference.value.instance import AnonymousInstance, BoundMethod, \
CompiledInstance, AbstractInstanceContext, TreeInstance
CompiledInstance, AbstractInstanceValue, TreeInstance

4
jedi/inference/value/decorator.py
View File

@@ -3,10 +3,10 @@ Decorators are not really values, however we need some wrappers to improve
docstrings and other things around decorators.
'''
from jedi.inference.base_value import ContextWrapper
from jedi.inference.base_value import ValueWrapper
class Decoratee(ContextWrapper):
class Decoratee(ValueWrapper):
def __init__(self, wrapped_value, original_value):
self._wrapped_value = wrapped_value
self._original_value = original_value

64
jedi/inference/value/function.py
View File

@@ -11,11 +11,11 @@ from jedi.inference import helpers
from jedi.inference.signature import TreeSignature
from jedi.inference.arguments import AnonymousArguments
from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter
from jedi.inference.names import ContextName, AbstractNameDefinition, ParamName
from jedi.inference.base_value import ContextualizedNode, NO_VALUES, \
ContextSet, TreeContext, ContextWrapper
from jedi.inference.lazy_value import LazyKnownContexts, LazyKnownContext, \
LazyTreeContext
from jedi.inference.names import ValueName, AbstractNameDefinition, ParamName
from jedi.inference.base_value import ValueualizedNode, NO_VALUES, \
ValueSet, TreeValue, ValueWrapper
from jedi.inference.lazy_value import LazyKnownValues, LazyKnownValue, \
LazyTreeValue
from jedi.inference.value import iterable
from jedi import parser_utils
from jedi.inference.parser_cache import get_yield_exprs
@@ -35,10 +35,10 @@ class LambdaName(AbstractNameDefinition):
return self._lambda_value.tree_node.start_pos
def infer(self):
return ContextSet([self._lambda_value])
return ValueSet([self._lambda_value])
class FunctionAndClassBase(TreeContext):
class FunctionAndClassBase(TreeValue):
def get_qualified_names(self):
if self.parent_value.is_class():
n = self.parent_value.get_qualified_names()
@@ -73,8 +73,8 @@ class FunctionMixin(object):
from jedi.inference.value.instance import BoundMethod
if instance is None:
# Calling the Foo.bar results in the original bar function.
return ContextSet([self])
return ContextSet([BoundMethod(instance, self)])
return ValueSet([self])
return ValueSet([BoundMethod(instance, self)])
def get_param_names(self):
function_execution = self.get_function_execution()
@@ -85,7 +85,7 @@ class FunctionMixin(object):
def name(self):
if self.tree_node.type == 'lambdef':
return LambdaName(self)
return ContextName(self, self.tree_node.name)
return ValueName(self, self.tree_node.name)
def py__name__(self):
return self.name.string_name
@@ -98,13 +98,13 @@ class FunctionMixin(object):
if arguments is None:
arguments = AnonymousArguments()
return FunctionExecutionContext(self.infer_state, self.parent_value, self, arguments)
return FunctionExecutionValue(self.infer_state, self.parent_value, self, arguments)
def get_signatures(self):
return [TreeSignature(f) for f in self.get_signature_functions()]
class FunctionContext(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndClassBase)):
class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndClassBase)):
def is_function(self):
return True
@@ -112,7 +112,7 @@ class FunctionContext(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndC
def from_value(cls, value, tree_node):
def create(tree_node):
if value.is_class():
return MethodContext(
return MethodValue(
value.infer_state,
value,
parent_value=parent_value,
@@ -134,7 +134,7 @@ class FunctionContext(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndC
function = create(tree_node)
if overloaded_funcs:
return OverloadedFunctionContext(
return OverloadedFunctionValue(
function,
[create(f) for f in overloaded_funcs]
)
@@ -151,9 +151,9 @@ class FunctionContext(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndC
return [self]
class MethodContext(FunctionContext):
class MethodValue(FunctionValue):
def __init__(self, infer_state, class_value, *args, **kwargs):
super(MethodContext, self).__init__(infer_state, *args, **kwargs)
super(MethodValue, self).__init__(infer_state, *args, **kwargs)
self.class_value = class_value
def get_default_param_value(self):
@@ -168,11 +168,11 @@ class MethodContext(FunctionContext):
return names + (self.py__name__(),)
class FunctionExecutionContext(TreeContext):
class FunctionExecutionValue(TreeValue):
function_execution_filter = FunctionExecutionFilter
def __init__(self, infer_state, parent_value, function_value, var_args):
super(FunctionExecutionContext, self).__init__(
super(FunctionExecutionValue, self).__init__(
infer_state,
parent_value,
function_value.tree_node,
@@ -206,7 +206,7 @@ class FunctionExecutionContext(TreeContext):
debug.dbg('Return unreachable: %s', r)
else:
if check_yields:
value_set |= ContextSet.from_sets(
value_set |= ValueSet.from_sets(
lazy_value.infer()
for lazy_value in self._get_yield_lazy_value(r)
)
@@ -215,7 +215,7 @@ class FunctionExecutionContext(TreeContext):
children = r.children
except AttributeError:
ctx = compiled.builtin_from_name(self.infer_state, u'None')
value_set |= ContextSet([ctx])
value_set |= ValueSet([ctx])
else:
value_set |= self.infer_node(children[1])
if check is flow_analysis.REACHABLE:
@@ -227,16 +227,16 @@ class FunctionExecutionContext(TreeContext):
if yield_expr.type == 'keyword':
# `yield` just yields None.
ctx = compiled.builtin_from_name(self.infer_state, u'None')
yield LazyKnownContext(ctx)
yield LazyKnownValue(ctx)
return
node = yield_expr.children[1]
if node.type == 'yield_arg': # It must be a yield from.
cn = ContextualizedNode(self, node.children[1])
cn = ValueualizedNode(self, node.children[1])
for lazy_value in cn.infer().iterate(cn):
yield lazy_value
else:
yield LazyTreeContext(self, node)
yield LazyTreeValue(self, node)
@recursion.execution_recursion_decorator(default=iter([]))
def get_yield_lazy_values(self, is_async=False):
@@ -265,7 +265,7 @@ class FunctionExecutionContext(TreeContext):
else:
types = self.get_return_values(check_yields=True)
if types:
yield LazyKnownContexts(types)
yield LazyKnownValues(types)
return
last_for_stmt = for_stmt
@@ -277,7 +277,7 @@ class FunctionExecutionContext(TreeContext):
yield result
else:
input_node = for_stmt.get_testlist()
cn = ContextualizedNode(self, input_node)
cn = ValueualizedNode(self, input_node)
ordered = cn.infer().iterate(cn)
ordered = list(ordered)
for lazy_value in ordered:
@@ -288,7 +288,7 @@ class FunctionExecutionContext(TreeContext):
yield result
def merge_yield_values(self, is_async=False):
return ContextSet.from_sets(
return ValueSet.from_sets(
lazy_value.infer()
for lazy_value in self.get_yield_lazy_values()
)
@@ -338,7 +338,7 @@ class FunctionExecutionContext(TreeContext):
yield_values = self.merge_yield_values(is_async=True)
# The contravariant doesn't seem to be defined.
generics = (yield_values.py__class__(), NO_VALUES)
return ContextSet(
return ValueSet(
# In Python 3.6 AsyncGenerator is still a class.
GenericClass(c, generics)
for c in async_generator_classes
@@ -350,19 +350,19 @@ class FunctionExecutionContext(TreeContext):
return_values = self.get_return_values()
# Only the first generic is relevant.
generics = (return_values.py__class__(), NO_VALUES, NO_VALUES)
return ContextSet(
return ValueSet(
GenericClass(c, generics) for c in async_classes
).execute_annotation()
else:
if is_generator:
return ContextSet([iterable.Generator(infer_state, self)])
return ValueSet([iterable.Generator(infer_state, self)])
else:
return self.get_return_values()
class OverloadedFunctionContext(FunctionMixin, ContextWrapper):
class OverloadedFunctionValue(FunctionMixin, ValueWrapper):
def __init__(self, function, overloaded_functions):
super(OverloadedFunctionContext, self).__init__(function)
super(OverloadedFunctionValue, self).__init__(function)
self._overloaded_functions = overloaded_functions
def py__call__(self, arguments):
@@ -383,7 +383,7 @@ class OverloadedFunctionContext(FunctionMixin, ContextWrapper):
if self.infer_state.is_analysis:
# In this case we want precision.
return NO_VALUES
return ContextSet.from_sets(fe.infer() for fe in function_executions)
return ValueSet.from_sets(fe.infer() for fe in function_executions)
def get_signature_functions(self):
return self._overloaded_functions

56
jedi/inference/value/instance.py
View File

@@ -6,16 +6,16 @@ from jedi.inference import compiled
from jedi.inference.compiled.value import CompiledObjectFilter
from jedi.inference.helpers import values_from_qualified_names
from jedi.inference.filters import AbstractFilter
from jedi.inference.names import ContextName, TreeNameDefinition
from jedi.inference.base_value import Context, NO_VALUES, ContextSet, \
iterator_to_value_set, ContextWrapper
from jedi.inference.lazy_value import LazyKnownContext, LazyKnownContexts
from jedi.inference.names import ValueName, TreeNameDefinition
from jedi.inference.base_value import Value, NO_VALUES, ValueSet, \
iterator_to_value_set, ValueWrapper
from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.arguments import AnonymousArguments, \
ValuesArguments, TreeArgumentsWrapper
from jedi.inference.value.function import \
FunctionContext, FunctionMixin, OverloadedFunctionContext
from jedi.inference.value.klass import ClassContext, apply_py__get__, \
FunctionValue, FunctionMixin, OverloadedFunctionValue
from jedi.inference.value.klass import ClassValue, apply_py__get__, \
ClassFilter
from jedi.inference.value import iterable
from jedi.parser_utils import get_parent_scope
@@ -28,7 +28,7 @@ class InstanceExecutedParam(object):
self.string_name = self._tree_param.name.value
def infer(self):
return ContextSet([self._instance])
return ValueSet([self._instance])
def matches_signature(self):
return True
@@ -58,11 +58,11 @@ class AnonymousInstanceArguments(AnonymousArguments):
return executed_params, []
class AbstractInstanceContext(Context):
class AbstractInstanceValue(Value):
api_type = u'instance'
def __init__(self, infer_state, parent_value, class_value, var_args):
super(AbstractInstanceContext, self).__init__(infer_state, parent_value)
super(AbstractInstanceValue, self).__init__(infer_state, parent_value)
# Generated instances are classes that are just generated by self
# (No var_args) used.
self.class_value = class_value
@@ -81,9 +81,9 @@ class AbstractInstanceContext(Context):
names = self.get_function_slot_names(u'__call__')
if not names:
# Means the Instance is not callable.
return super(AbstractInstanceContext, self).py__call__(arguments)
return super(AbstractInstanceValue, self).py__call__(arguments)
return ContextSet.from_sets(name.infer().execute(arguments) for name in names)
return ValueSet.from_sets(name.infer().execute(arguments) for name in names)
def py__class__(self):
return self.class_value
@@ -103,7 +103,7 @@ class AbstractInstanceContext(Context):
return []
def execute_function_slots(self, names, *inferred_args):
return ContextSet.from_sets(
return ValueSet.from_sets(
name.infer().execute_with_values(*inferred_args)
for name in names
)
@@ -120,7 +120,7 @@ class AbstractInstanceContext(Context):
obj = compiled.builtin_from_name(self.infer_state, u'None')
return self.execute_function_slots(names, obj, class_value)
else:
return ContextSet([self])
return ValueSet([self])
def get_filters(self, search_global=None, until_position=None,
origin_scope=None, include_self_names=True):
@@ -151,18 +151,18 @@ class AbstractInstanceContext(Context):
def py__getitem__(self, index_value_set, valueualized_node):
names = self.get_function_slot_names(u'__getitem__')
if not names:
return super(AbstractInstanceContext, self).py__getitem__(
return super(AbstractInstanceValue, self).py__getitem__(
index_value_set,
valueualized_node,
)
args = ValuesArguments([index_value_set])
return ContextSet.from_sets(name.infer().execute(args) for name in names)
return ValueSet.from_sets(name.infer().execute(args) for name in names)
def py__iter__(self, valueualized_node=None):
iter_slot_names = self.get_function_slot_names(u'__iter__')
if not iter_slot_names:
return super(AbstractInstanceContext, self).py__iter__(valueualized_node)
return super(AbstractInstanceValue, self).py__iter__(valueualized_node)
def iterate():
for generator in self.execute_function_slots(iter_slot_names):
@@ -174,7 +174,7 @@ class AbstractInstanceContext(Context):
name = u'__next__'
next_slot_names = generator.get_function_slot_names(name)
if next_slot_names:
yield LazyKnownContexts(
yield LazyKnownValues(
generator.execute_function_slots(next_slot_names)
)
else:
@@ -192,7 +192,7 @@ class AbstractInstanceContext(Context):
for name in self.get_function_slot_names(u'__init__'):
# TODO is this correct? I think we need to check for functions.
if isinstance(name, LazyInstanceClassName):
function = FunctionContext.from_value(
function = FunctionValue.from_value(
self.parent_value,
name.tree_name.parent
)
@@ -209,7 +209,7 @@ class AbstractInstanceContext(Context):
else:
parent_value = self.create_instance_value(class_value, scope)
if scope.type == 'funcdef':
func = FunctionContext.from_value(
func = FunctionValue.from_value(
parent_value,
scope,
)
@@ -219,7 +219,7 @@ class AbstractInstanceContext(Context):
else:
return bound_method.get_function_execution()
elif scope.type == 'classdef':
class_value = ClassContext(self.infer_state, parent_value, scope)
class_value = ClassValue(self.infer_state, parent_value, scope)
return class_value
elif scope.type in ('comp_for', 'sync_comp_for'):
# Comprehensions currently don't have a special scope in Jedi.
@@ -237,14 +237,14 @@ class AbstractInstanceContext(Context):
self.var_args)
class CompiledInstance(AbstractInstanceContext):
class CompiledInstance(AbstractInstanceValue):
def __init__(self, infer_state, parent_value, class_value, var_args):
self._original_var_args = var_args
super(CompiledInstance, self).__init__(infer_state, parent_value, class_value, var_args)
@property
def name(self):
return compiled.CompiledContextName(self, self.class_value.name.string_name)
return compiled.CompiledValueName(self, self.class_value.name.string_name)
def get_first_non_keyword_argument_values(self):
key, lazy_value = next(self._original_var_args.unpack(), ('', None))
@@ -257,7 +257,7 @@ class CompiledInstance(AbstractInstanceContext):
return False
class TreeInstance(AbstractInstanceContext):
class TreeInstance(AbstractInstanceValue):
def __init__(self, infer_state, parent_value, class_value, var_args):
# I don't think that dynamic append lookups should happen here. That
# sounds more like something that should go to py__iter__.
@@ -273,7 +273,7 @@ class TreeInstance(AbstractInstanceContext):
@property
def name(self):
return ContextName(self, self.class_value.name.tree_name)
return ValueName(self, self.class_value.name.tree_name)
# This can recurse, if the initialization of the class includes a reference
# to itself.
@@ -367,7 +367,7 @@ class CompiledInstanceClassFilter(AbstractFilter):
]
class BoundMethod(FunctionMixin, ContextWrapper):
class BoundMethod(FunctionMixin, ValueWrapper):
def __init__(self, instance, function):
super(BoundMethod, self).__init__(function)
self.instance = instance
@@ -390,7 +390,7 @@ class BoundMethod(FunctionMixin, ContextWrapper):
return super(BoundMethod, self).get_function_execution(arguments)
def py__call__(self, arguments):
if isinstance(self._wrapped_value, OverloadedFunctionContext):
if isinstance(self._wrapped_value, OverloadedFunctionValue):
return self._wrapped_value.py__call__(self._get_arguments(arguments))
function_execution = self.get_function_execution(arguments)
@@ -409,7 +409,7 @@ class BoundMethod(FunctionMixin, ContextWrapper):
return '<%s: %s>' % (self.__class__.__name__, self._wrapped_value)
class CompiledBoundMethod(ContextWrapper):
class CompiledBoundMethod(ValueWrapper):
def is_bound_method(self):
return True
@@ -517,7 +517,7 @@ class InstanceArguments(TreeArgumentsWrapper):
self.instance = instance
def unpack(self, func=None):
yield None, LazyKnownContext(self.instance)
yield None, LazyKnownValue(self.instance)
for values in self._wrapped_arguments.unpack(func):
yield values

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

@@ -28,8 +28,8 @@ from jedi._compatibility import force_unicode, is_py3
from jedi.inference import compiled
from jedi.inference import analysis
from jedi.inference import recursion
from jedi.inference.lazy_value import LazyKnownContext, LazyKnownContexts, \
LazyTreeContext
from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
LazyTreeValue
from jedi.inference.helpers import get_int_or_none, is_string, \
predefine_names, infer_call_of_leaf, reraise_getitem_errors, \
SimpleGetItemNotFound
@@ -37,14 +37,14 @@ from jedi.inference.utils import safe_property, to_list
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.filters import ParserTreeFilter, LazyAttributeOverwrite, \
publish_method
from jedi.inference.base_value import ContextSet, Context, NO_VALUES, \
TreeContext, ContextualizedNode, iterate_values, HelperContextMixin, _sentinel
from jedi.inference.base_value import ValueSet, Value, NO_VALUES, \
TreeValue, ValueualizedNode, iterate_values, HelperValueMixin, _sentinel
from jedi.parser_utils import get_sync_comp_fors
class IterableMixin(object):
def py__stop_iteration_returns(self):
return ContextSet([compiled.builtin_from_name(self.infer_state, u'None')])
return ValueSet([compiled.builtin_from_name(self.infer_state, u'None')])
# At the moment, safe values are simple values like "foo", 1 and not
# lists/dicts. Therefore as a small speed optimization we can just do the
@@ -59,7 +59,7 @@ class IterableMixin(object):
raise ValueError("There exists no safe value for value %s" % self)
return default
else:
get_safe_value = Context.get_safe_value
get_safe_value = Value.get_safe_value
class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
@@ -79,20 +79,20 @@ class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
@publish_method('__iter__')
def py__iter__(self, valueualized_node=None):
return ContextSet([self])
return ValueSet([self])
@publish_method('send')
@publish_method('next', python_version_match=2)
@publish_method('__next__', python_version_match=3)
def py__next__(self):
return ContextSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
def py__stop_iteration_returns(self):
return ContextSet([compiled.builtin_from_name(self.infer_state, u'None')])
return ValueSet([compiled.builtin_from_name(self.infer_state, u'None')])
@property
def name(self):
return compiled.CompiledContextName(self, 'Generator')
return compiled.CompiledValueName(self, 'Generator')
class Generator(GeneratorBase):
@@ -111,7 +111,7 @@ class Generator(GeneratorBase):
return "<%s of %s>" % (type(self).__name__, self._func_execution_value)
class CompForContext(TreeContext):
class CompForValue(TreeValue):
@classmethod
def from_comp_for(cls, parent_value, comp_for):
return cls(parent_value.infer_state, parent_value, comp_for)
@@ -159,7 +159,7 @@ def comprehension_from_atom(infer_state, value, atom):
class ComprehensionMixin(object):
@infer_state_method_cache()
def _get_comp_for_value(self, parent_value, comp_for):
return CompForContext.from_comp_for(parent_value, comp_for)
return CompForValue.from_comp_for(parent_value, comp_for)
def _nested(self, comp_fors, parent_value=None):
comp_for = comp_fors[0]
@@ -171,7 +171,7 @@ class ComprehensionMixin(object):
input_types = parent_value.infer_node(input_node)
# TODO: simulate await if self.is_async
cn = ContextualizedNode(parent_value, input_node)
cn = ValueualizedNode(parent_value, input_node)
iterated = input_types.iterate(cn, is_async=is_async)
exprlist = comp_for.children[1]
for i, lazy_value in enumerate(iterated):
@@ -201,7 +201,7 @@ class ComprehensionMixin(object):
def py__iter__(self, valueualized_node=None):
for set_ in self._iterate():
yield LazyKnownContexts(set_)
yield LazyKnownValues(set_)
def __repr__(self):
return "<%s of %s>" % (type(self).__name__, self._sync_comp_for_node)
@@ -217,7 +217,7 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
@property
def name(self):
return compiled.CompiledContextName(self, self.array_type)
return compiled.CompiledValueName(self, self.array_type)
def _get_generics(self):
return (self.merge_types_of_iterate().py__class__(),)
@@ -241,7 +241,7 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
def py__getitem__(self, index_value_set, valueualized_node):
if self.array_type == 'dict':
return self._dict_values()
return iterate_values(ContextSet([self]))
return iterate_values(ValueSet([self]))
class _BaseComprehension(ComprehensionMixin):
@@ -258,7 +258,7 @@ class ListComprehension(_BaseComprehension, Sequence):
def py__simple_getitem__(self, index):
if isinstance(index, slice):
return ContextSet([self])
return ValueSet([self])
all_types = list(self.py__iter__())
with reraise_getitem_errors(IndexError, TypeError):
@@ -287,7 +287,7 @@ class DictComprehension(ComprehensionMixin, Sequence):
def py__iter__(self, valueualized_node=None):
for keys, values in self._iterate():
yield LazyKnownContexts(keys)
yield LazyKnownValues(keys)
def py__simple_getitem__(self, index):
for keys, values in self._iterate():
@@ -300,31 +300,31 @@ class DictComprehension(ComprehensionMixin, Sequence):
raise SimpleGetItemNotFound()
def _dict_keys(self):
return ContextSet.from_sets(keys for keys, values in self._iterate())
return ValueSet.from_sets(keys for keys, values in self._iterate())
def _dict_values(self):
return ContextSet.from_sets(values for keys, values in self._iterate())
return ValueSet.from_sets(values for keys, values in self._iterate())
@publish_method('values')
def _imitate_values(self):
lazy_value = LazyKnownContexts(self._dict_values())
return ContextSet([FakeSequence(self.infer_state, u'list', [lazy_value])])
lazy_value = LazyKnownValues(self._dict_values())
return ValueSet([FakeSequence(self.infer_state, u'list', [lazy_value])])
@publish_method('items')
def _imitate_items(self):
lazy_values = [
LazyKnownContext(
LazyKnownValue(
FakeSequence(
self.infer_state,
u'tuple',
[LazyKnownContexts(key),
LazyKnownContexts(value)]
[LazyKnownValues(key),
LazyKnownValues(value)]
)
)
for key, value in self._iterate()
]
return ContextSet([FakeSequence(self.infer_state, u'list', lazy_values)])
return ValueSet([FakeSequence(self.infer_state, u'list', lazy_values)])
def get_mapping_item_values(self):
return self._dict_keys(), self._dict_values()
@@ -335,21 +335,21 @@ class DictComprehension(ComprehensionMixin, Sequence):
return []
class SequenceLiteralContext(Sequence):
class SequenceLiteralValue(Sequence):
_TUPLE_LIKE = 'testlist_star_expr', 'testlist', 'subscriptlist'
mapping = {'(': u'tuple',
'[': u'list',
'{': u'set'}
def __init__(self, infer_state, defining_value, atom):
super(SequenceLiteralContext, self).__init__(infer_state)
super(SequenceLiteralValue, self).__init__(infer_state)
self.atom = atom
self._defining_value = defining_value
if self.atom.type in self._TUPLE_LIKE:
self.array_type = u'tuple'
else:
self.array_type = SequenceLiteralContext.mapping[atom.children[0]]
self.array_type = SequenceLiteralValue.mapping[atom.children[0]]
"""The builtin name of the array (list, set, tuple or dict)."""
def py__simple_getitem__(self, index):
@@ -368,7 +368,7 @@ class SequenceLiteralContext(Sequence):
raise SimpleGetItemNotFound('No key found in dictionary %s.' % self)
if isinstance(index, slice):
return ContextSet([self])
return ValueSet([self])
else:
with reraise_getitem_errors(TypeError, KeyError, IndexError):
node = self.get_tree_entries()[index]
@@ -387,15 +387,15 @@ class SequenceLiteralContext(Sequence):
# We don't know which dict index comes first, therefore always
# yield all the types.
for _ in types:
yield LazyKnownContexts(types)
yield LazyKnownValues(types)
else:
for node in self.get_tree_entries():
if node == ':' or node.type == 'subscript':
# TODO this should probably use at least part of the code
# of infer_subscript_list.
yield LazyKnownContext(Slice(self._defining_value, None, None, None))
yield LazyKnownValue(Slice(self._defining_value, None, None, None))
else:
yield LazyTreeContext(self._defining_value, node)
yield LazyTreeValue(self._defining_value, node)
for addition in check_array_additions(self._defining_value, self):
yield addition
@@ -404,7 +404,7 @@ class SequenceLiteralContext(Sequence):
return len(self.get_tree_entries())
def _dict_values(self):
return ContextSet.from_sets(
return ValueSet.from_sets(
self._defining_value.infer_node(v)
for k, v in self.get_tree_entries()
)
@@ -462,39 +462,39 @@ class SequenceLiteralContext(Sequence):
for key_node, value in self.get_tree_entries():
for key in self._defining_value.infer_node(key_node):
if is_string(key):
yield key.get_safe_value(), LazyTreeContext(self._defining_value, value)
yield key.get_safe_value(), LazyTreeValue(self._defining_value, value)
def __repr__(self):
return "<%s of %s>" % (self.__class__.__name__, self.atom)
class DictLiteralContext(_DictMixin, SequenceLiteralContext):
class DictLiteralValue(_DictMixin, SequenceLiteralValue):
array_type = u'dict'
def __init__(self, infer_state, defining_value, atom):
super(SequenceLiteralContext, self).__init__(infer_state)
super(SequenceLiteralValue, self).__init__(infer_state)
self._defining_value = defining_value
self.atom = atom
@publish_method('values')
def _imitate_values(self):
lazy_value = LazyKnownContexts(self._dict_values())
return ContextSet([FakeSequence(self.infer_state, u'list', [lazy_value])])
lazy_value = LazyKnownValues(self._dict_values())
return ValueSet([FakeSequence(self.infer_state, u'list', [lazy_value])])
@publish_method('items')
def _imitate_items(self):
lazy_values = [
LazyKnownContext(FakeSequence(
LazyKnownValue(FakeSequence(
self.infer_state, u'tuple',
(LazyTreeContext(self._defining_value, key_node),
LazyTreeContext(self._defining_value, value_node))
(LazyTreeValue(self._defining_value, key_node),
LazyTreeValue(self._defining_value, value_node))
)) for key_node, value_node in self.get_tree_entries()
]
return ContextSet([FakeSequence(self.infer_state, u'list', lazy_values)])
return ValueSet([FakeSequence(self.infer_state, u'list', lazy_values)])
def _dict_keys(self):
return ContextSet.from_sets(
return ValueSet.from_sets(
self._defining_value.infer_node(k)
for k, v in self.get_tree_entries()
)
@@ -503,9 +503,9 @@ class DictLiteralContext(_DictMixin, SequenceLiteralContext):
return self._dict_keys(), self._dict_values()
class _FakeArray(SequenceLiteralContext):
class _FakeArray(SequenceLiteralValue):
def __init__(self, infer_state, container, type):
super(SequenceLiteralContext, self).__init__(infer_state)
super(SequenceLiteralValue, self).__init__(infer_state)
self.array_type = type
self.atom = container
# TODO is this class really needed?
@@ -521,7 +521,7 @@ class FakeSequence(_FakeArray):
def py__simple_getitem__(self, index):
if isinstance(index, slice):
return ContextSet([self])
return ValueSet([self])
with reraise_getitem_errors(IndexError, TypeError):
lazy_value = self._lazy_value_list[index]
@@ -544,7 +544,7 @@ class FakeDict(_DictMixin, _FakeArray):
def py__iter__(self, valueualized_node=None):
for key in self._dct:
yield LazyKnownContext(compiled.create_simple_object(self.infer_state, key))
yield LazyKnownValue(compiled.create_simple_object(self.infer_state, key))
def py__simple_getitem__(self, index):
if is_py3 and self.infer_state.environment.version_info.major == 2:
@@ -568,16 +568,16 @@ class FakeDict(_DictMixin, _FakeArray):
@publish_method('values')
def _values(self):
return ContextSet([FakeSequence(
return ValueSet([FakeSequence(
self.infer_state, u'tuple',
[LazyKnownContexts(self._dict_values())]
[LazyKnownValues(self._dict_values())]
)])
def _dict_values(self):
return ContextSet.from_sets(lazy_value.infer() for lazy_value in self._dct.values())
return ValueSet.from_sets(lazy_value.infer() for lazy_value in self._dct.values())
def _dict_keys(self):
return ContextSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
def get_mapping_item_values(self):
return self._dict_keys(), self._dict_values()
@@ -597,7 +597,7 @@ class MergedArray(_FakeArray):
yield lazy_value
def py__simple_getitem__(self, index):
return ContextSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
def get_tree_entries(self):
for array in self._arrays:
@@ -744,10 +744,10 @@ def get_dynamic_array_instance(instance, arguments):
"""Used for set() and list() instances."""
ai = _ArrayInstance(instance, arguments)
from jedi.inference import arguments
return arguments.ValuesArguments([ContextSet([ai])])
return arguments.ValuesArguments([ValueSet([ai])])
class _ArrayInstance(HelperContextMixin):
class _ArrayInstance(HelperValueMixin):
"""
Used for the usage of set() and list().
This is definitely a hack, but a good one :-)

30
jedi/inference/value/klass.py
View File

@@ -25,7 +25,7 @@ py__iter__() Returns a generator of a set of types.
py__class__() Returns the class of an instance.
py__simple_getitem__(index: int/str) Returns a a set of types of the index.
Can raise an IndexError/KeyError.
py__getitem__(indexes: ContextSet) Returns a a set of types of the index.
py__getitem__(indexes: ValueSet) Returns a a set of types of the index.
py__file__() Only on modules. Returns None if does
not exist.
py__package__() -> List[str] Only on modules. For the import system.
@@ -42,11 +42,11 @@ from jedi.parser_utils import get_cached_parent_scope
from jedi.inference.cache import infer_state_method_cache, CachedMetaClass, \
infer_state_method_generator_cache
from jedi.inference import compiled
from jedi.inference.lazy_value import LazyKnownContexts
from jedi.inference.lazy_value import LazyKnownValues
from jedi.inference.filters import ParserTreeFilter
from jedi.inference.names import TreeNameDefinition, ContextName
from jedi.inference.names import TreeNameDefinition, ValueName
from jedi.inference.arguments import unpack_arglist, ValuesArguments
from jedi.inference.base_value import ContextSet, iterator_to_value_set, \
from jedi.inference.base_value import ValueSet, iterator_to_value_set, \
NO_VALUES
from jedi.inference.value.function import FunctionAndClassBase
from jedi.plugins import plugin_manager
@@ -141,14 +141,14 @@ class ClassMixin(object):
from jedi.inference.value import TreeInstance
if arguments is None:
arguments = ValuesArguments([])
return ContextSet([TreeInstance(self.infer_state, self.parent_value, self, arguments)])
return ValueSet([TreeInstance(self.infer_state, self.parent_value, self, arguments)])
def py__class__(self):
return compiled.builtin_from_name(self.infer_state, u'type')
@property
def name(self):
return ContextName(self, self.tree_node.name)
return ValueName(self, self.tree_node.name)
def py__name__(self):
return self.name.string_name
@@ -215,7 +215,7 @@ class ClassMixin(object):
if not is_instance:
from jedi.inference.compiled import builtin_from_name
type_ = builtin_from_name(self.infer_state, u'type')
assert isinstance(type_, ClassContext)
assert isinstance(type_, ClassValue)
if type_ != self:
for instance in type_.py__call__():
instance_filters = instance.get_filters()
@@ -237,7 +237,7 @@ class ClassMixin(object):
)
class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase)):
class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase)):
api_type = u'class'
@infer_state_method_cache()
@@ -276,15 +276,15 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
if self.py__name__() == 'object' \
and self.parent_value == self.infer_state.builtins_module:
return []
return [LazyKnownContexts(
return [LazyKnownValues(
self.infer_state.builtins_module.py__getattribute__('object')
)]
def py__getitem__(self, index_value_set, valueualized_node):
from jedi.inference.gradual.typing import LazyGenericClass
if not index_value_set:
return ContextSet([self])
return ContextSet(
return ValueSet([self])
return ValueSet(
LazyGenericClass(
self,
index_value,
@@ -310,11 +310,11 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
yield type_var_dict.get(type_var.py__name__(), NO_VALUES)
if type_var_dict:
return ContextSet([GenericClass(
return ValueSet([GenericClass(
self,
generics=tuple(remap_type_vars())
)])
return ContextSet({self})
return ValueSet({self})
@plugin_manager.decorate()
def get_metaclass_filters(self, metaclass):
@@ -326,8 +326,8 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
args = self._get_bases_arguments()
if args is not None:
m = [value for key, value in args.unpack() if key == 'metaclass']
metaclasses = ContextSet.from_sets(lazy_value.infer() for lazy_value in m)
metaclasses = ContextSet(m for m in metaclasses if m.is_class())
metaclasses = ValueSet.from_sets(lazy_value.infer() for lazy_value in m)
metaclasses = ValueSet(m for m in metaclasses if m.is_class())
if metaclasses:
return metaclasses

22
jedi/inference/value/module.py
View File

@@ -3,14 +3,14 @@ import os
from jedi import debug
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.names import ContextNameMixin, AbstractNameDefinition
from jedi.inference.names import ValueNameMixin, AbstractNameDefinition
from jedi.inference.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter
from jedi.inference import compiled
from jedi.inference.base_value import TreeContext
from jedi.inference.base_value import TreeValue
from jedi.inference.names import SubModuleName
from jedi.inference.helpers import values_from_qualified_names
from jedi.inference.compiled import create_simple_object
from jedi.inference.base_value import ContextSet
from jedi.inference.base_value import ValueSet
class _ModuleAttributeName(AbstractNameDefinition):
@@ -30,13 +30,13 @@ class _ModuleAttributeName(AbstractNameDefinition):
if self.parent_value.infer_state.environment.version_info.major == 2 \
and not isinstance(s, bytes):
s = s.encode('utf-8')
return ContextSet([
return ValueSet([
create_simple_object(self.parent_value.infer_state, s)
])
return compiled.get_string_value_set(self.parent_value.infer_state)
class ModuleName(ContextNameMixin, AbstractNameDefinition):
class ModuleName(ValueNameMixin, AbstractNameDefinition):
start_pos = 1, 0
def __init__(self, value, name):
@@ -132,7 +132,7 @@ class ModuleMixin(SubModuleDictMixin):
def _string_name(self):
""" This is used for the goto functions. """
# TODO It's ugly that we even use this, the name is usually well known
# ahead so just pass it when create a ModuleContext.
# ahead so just pass it when create a ModuleValue.
if self._path is None:
return '' # no path -> empty name
else:
@@ -173,7 +173,7 @@ class ModuleMixin(SubModuleDictMixin):
).follow()
for module in new:
if isinstance(module, ModuleContext):
if isinstance(module, ModuleValue):
modules += module.star_imports()
modules += new
return modules
@@ -187,12 +187,12 @@ class ModuleMixin(SubModuleDictMixin):
return ()
class ModuleContext(ModuleMixin, TreeContext):
class ModuleValue(ModuleMixin, TreeValue):
api_type = u'module'
parent_value = None
def __init__(self, infer_state, module_node, file_io, string_names, code_lines, is_package=False):
super(ModuleContext, self).__init__(
super(ModuleValue, self).__init__(
infer_state,
parent_value=None,
tree_node=module_node
@@ -210,9 +210,9 @@ class ModuleContext(ModuleMixin, TreeContext):
if self._path is not None and self._path.endswith('.pyi'):
# Currently this is the way how we identify stubs when e.g. goto is
# used in them. This could be changed if stubs would be identified
# sooner and used as StubModuleContext.
# sooner and used as StubModuleValue.
return True
return super(ModuleContext, self).is_stub()
return super(ModuleValue, self).is_stub()
def py__name__(self):
if self.string_names is None:

10
jedi/inference/value/namespace.py
View File

@@ -1,11 +1,11 @@
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.filters import DictFilter
from jedi.inference.names import ContextNameMixin, AbstractNameDefinition
from jedi.inference.base_value import Context
from jedi.inference.names import ValueNameMixin, AbstractNameDefinition
from jedi.inference.base_value import Value
from jedi.inference.value.module import SubModuleDictMixin
class ImplicitNSName(ContextNameMixin, AbstractNameDefinition):
class ImplicitNSName(ValueNameMixin, AbstractNameDefinition):
"""
Accessing names for implicit namespace packages should infer to nothing.
This object will prevent Jedi from raising exceptions
@@ -15,7 +15,7 @@ class ImplicitNSName(ContextNameMixin, AbstractNameDefinition):
self.string_name = string_name
class ImplicitNamespaceContext(Context, SubModuleDictMixin):
class ImplicitNamespaceValue(Value, SubModuleDictMixin):
"""
Provides support for implicit namespace packages
"""
@@ -26,7 +26,7 @@ class ImplicitNamespaceContext(Context, SubModuleDictMixin):
parent_value = None
def __init__(self, infer_state, fullname, paths):
super(ImplicitNamespaceContext, self).__init__(infer_state, parent_value=None)
super(ImplicitNamespaceValue, self).__init__(infer_state, parent_value=None)
self.infer_state = infer_state
self._fullname = fullname
self._paths = paths