VimPlug/jedi
1
0
Fork 1
mirror of https://github.com/davidhalter/jedi.git synced 2026-05-25 01:38:36 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

parent_value -> parent_context

Browse Source
This commit is contained in:
Dave Halter
2019-08-15 09:36:46 +02:00
parent 2e90e3b2b1
commit 600272366f
25 changed files with 181 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jedi/api/classes.py
+1 -1
View File
@@ -360,7 +360,7 @@ class BaseDefinition(object):
if not self._name.is_value_name: if not self._name.is_value_name:
return None return None
value = self._name.parent_value value = self._name.parent_context
if value is None: if value is None:
return None return None
jedi/common/value.py
+4 -4
View File
@@ -1,14 +1,14 @@
class BaseValue(object): class BaseValue(object):
def __init__(self, infer_state, parent_value=None): def __init__(self, infer_state, parent_context=None):
self.infer_state = infer_state self.infer_state = infer_state
self.parent_value = parent_value self.parent_context = parent_context
def get_root_value(self): def get_root_value(self):
value = self value = self
while True: while True:
if value.parent_value is None: if value.parent_context is None:
return value return value
value = value.parent_value value = value.parent_context
class BaseValueSet(object): class BaseValueSet(object):
jedi/inference/__init__.py
+7 -7
View File
@@ -390,13 +390,13 @@ class InferState(object):
is_funcdef = scope_node.type in ('funcdef', 'lambdef') is_funcdef = scope_node.type in ('funcdef', 'lambdef')
parent_scope = parser_utils.get_parent_scope(scope_node) parent_scope = parser_utils.get_parent_scope(scope_node)
parent_value = from_scope_node(parent_scope) parent_context = from_scope_node(parent_scope)
if is_funcdef: if is_funcdef:
func = FunctionValue.from_value(parent_value, scope_node) func = FunctionValue.from_value(parent_context, scope_node)
if parent_value.is_class(): if parent_context.is_class():
instance = AnonymousInstance( instance = AnonymousInstance(
self, parent_value.parent_value, parent_value) self, parent_context.parent_context, parent_context)
func = BoundMethod( func = BoundMethod(
instance=instance, instance=instance,
function=func function=func
@@ -406,11 +406,11 @@ class InferState(object):
return func.get_function_execution() return func.get_function_execution()
return func return func
elif scope_node.type == 'classdef': elif scope_node.type == 'classdef':
return ClassValue(self, parent_value, scope_node) return ClassValue(self, parent_context, scope_node)
elif scope_node.type in ('comp_for', 'sync_comp_for'): elif scope_node.type in ('comp_for', 'sync_comp_for'):
if node.start_pos >= scope_node.children[-1].start_pos: if node.start_pos >= scope_node.children[-1].start_pos:
return parent_value return parent_context
return CompForValue.from_comp_for(parent_value, scope_node) return CompForValue.from_comp_for(parent_context, scope_node)
raise Exception("There's a scope that was not managed.") raise Exception("There's a scope that was not managed.")
base_node = base_value.tree_node base_node = base_value.tree_node
jedi/inference/analysis.py
+2 -2
View File
@@ -124,7 +124,7 @@ def add_attribute_error(name_value, lookup_value, name):
for n in slot_names: for n in slot_names:
# TODO do we even get here? # TODO do we even get here?
if isinstance(name, CompiledInstanceName) and \ if isinstance(name, CompiledInstanceName) and \
n.parent_value.obj == object: n.parent_context.obj == object:
typ = Warning typ = Warning
break break
@@ -149,7 +149,7 @@ def _check_for_exception_catch(node_value, jedi_name, exception, payload=None):
for python_cls in exception.mro(): for python_cls in exception.mro():
if cls.py__name__() == python_cls.__name__ \ if cls.py__name__() == python_cls.__name__ \
and cls.parent_value == cls.infer_state.builtins_module: and cls.parent_context == cls.infer_state.builtins_module:
return True return True
return False return False
jedi/inference/base_value.py
+5 -5
View File
@@ -26,9 +26,9 @@ class HelperValueMixin(object):
def get_root_value(self): def get_root_value(self):
value = self value = self
while True: while True:
if value.parent_value is None: if value.parent_context is None:
return value return value
value = value.parent_value value = value.parent_context
@classmethod @classmethod
@infer_state_as_method_param_cache() @infer_state_as_method_param_cache()
@@ -211,7 +211,7 @@ class Value(HelperValueMixin, BaseValue):
def is_stub(self): def is_stub(self):
# The root value knows if it's a stub or not. # The root value knows if it's a stub or not.
return self.parent_value.is_stub() return self.parent_context.is_stub()
def iterate_values(values, valueualized_node=None, is_async=False): def iterate_values(values, valueualized_node=None, is_async=False):
@@ -271,8 +271,8 @@ class ValueWrapper(_ValueWrapperBase):
class TreeValue(Value): class TreeValue(Value):
def __init__(self, infer_state, parent_value, tree_node): def __init__(self, infer_state, parent_context, tree_node):
super(TreeValue, self).__init__(infer_state, parent_value) super(TreeValue, self).__init__(infer_state, parent_context)
self.predefined_names = {} self.predefined_names = {}
self.tree_node = tree_node self.tree_node = tree_node
jedi/inference/compiled/access.py
+3 -3
View File
@@ -109,7 +109,7 @@ def compiled_objects_cache(attribute_name):
Caching the id has the advantage that an object doesn't need to be Caching the id has the advantage that an object doesn't need to be
hashable. hashable.
""" """
def wrapper(infer_state, obj, parent_value=None): def wrapper(infer_state, obj, parent_context=None):
cache = getattr(infer_state, attribute_name) cache = getattr(infer_state, attribute_name)
# Do a very cheap form of caching here. # Do a very cheap form of caching here.
key = id(obj) key = id(obj)
@@ -119,11 +119,11 @@ def compiled_objects_cache(attribute_name):
except KeyError: except KeyError:
# TODO wuaaaarrghhhhhhhh # TODO wuaaaarrghhhhhhhh
if attribute_name == 'mixed_cache': if attribute_name == 'mixed_cache':
result = func(infer_state, obj, parent_value) result = func(infer_state, obj, parent_context)
else: else:
result = func(infer_state, obj) result = func(infer_state, obj)
# Need to cache all of them, otherwise the id could be overwritten. # Need to cache all of them, otherwise the id could be overwritten.
cache[key] = result, obj, parent_value cache[key] = result, obj, parent_context
return result return result
return wrapper return wrapper
jedi/inference/compiled/mixed.py
+7 -7
View File
@@ -97,7 +97,7 @@ class MixedName(compiled.CompiledName):
@underscore_memoization @underscore_memoization
def infer(self): def infer(self):
# TODO use logic from compiled.CompiledObjectFilter # TODO use logic from compiled.CompiledObjectFilter
access_paths = self.parent_value.access_handle.getattr_paths( access_paths = self.parent_context.access_handle.getattr_paths(
self.string_name, self.string_name,
default=None default=None
) )
@@ -105,7 +105,7 @@ class MixedName(compiled.CompiledName):
values = [None] values = [None]
for access in access_paths: for access in access_paths:
values = ValueSet.from_sets( values = ValueSet.from_sets(
_create(self._infer_state, access, parent_value=c) _create(self._infer_state, access, parent_context=c)
if c is None or isinstance(c, MixedObject) if c is None or isinstance(c, MixedObject)
else ValueSet({create_cached_compiled_object(c.infer_state, access, c)}) else ValueSet({create_cached_compiled_object(c.infer_state, access, c)})
for c in values for c in values
@@ -230,11 +230,11 @@ def _find_syntax_node_name(infer_state, python_object):
@compiled_objects_cache('mixed_cache') @compiled_objects_cache('mixed_cache')
def _create(infer_state, access_handle, parent_value, *args): def _create(infer_state, access_handle, parent_context, *args):
compiled_object = create_cached_compiled_object( compiled_object = create_cached_compiled_object(
infer_state, infer_state,
access_handle, access_handle,
parent_value=parent_value and parent_value.compiled_object parent_context=parent_context and parent_context.compiled_object
) )
# TODO accessing this is bad, but it probably doesn't matter that much, # TODO accessing this is bad, but it probably doesn't matter that much,
@@ -252,7 +252,7 @@ def _create(infer_state, access_handle, parent_value, *args):
else: else:
module_node, tree_node, file_io, code_lines = result module_node, tree_node, file_io, code_lines = result
if parent_value is None: if parent_context is None:
# TODO this __name__ is probably wrong. # TODO this __name__ is probably wrong.
name = compiled_object.get_root_value().py__name__() name = compiled_object.get_root_value().py__name__()
string_names = tuple(name.split('.')) string_names = tuple(name.split('.'))
@@ -266,12 +266,12 @@ def _create(infer_state, access_handle, parent_value, *args):
if name is not None: if name is not None:
infer_state.module_cache.add(string_names, ValueSet([module_value])) infer_state.module_cache.add(string_names, ValueSet([module_value]))
else: else:
if parent_value.tree_node.get_root_node() != module_node: if parent_context.tree_node.get_root_node() != module_node:
# This happens e.g. when __module__ is wrong, or when using # This happens e.g. when __module__ is wrong, or when using
# TypeVar('foo'), where Jedi uses 'foo' as the name and # TypeVar('foo'), where Jedi uses 'foo' as the name and
# Python's TypeVar('foo').__module__ will be typing. # Python's TypeVar('foo').__module__ will be typing.
return ValueSet({compiled_object}) return ValueSet({compiled_object})
module_value = parent_value.get_root_value() module_value = parent_context.get_root_value()
tree_values = ValueSet({ tree_values = ValueSet({
module_value.create_value( module_value.create_value(
jedi/inference/compiled/value.py
+24 -24
View File
@@ -41,8 +41,8 @@ class CheckAttribute(object):
class CompiledObject(Value): class CompiledObject(Value):
def __init__(self, infer_state, access_handle, parent_value=None): def __init__(self, infer_state, access_handle, parent_context=None):
super(CompiledObject, self).__init__(infer_state, parent_value) super(CompiledObject, self).__init__(infer_state, parent_context)
self.access_handle = access_handle self.access_handle = access_handle
def py__call__(self, arguments): def py__call__(self, arguments):
@@ -59,7 +59,7 @@ class CompiledObject(Value):
if self.access_handle.is_class(): if self.access_handle.is_class():
from jedi.inference.value import CompiledInstance from jedi.inference.value import CompiledInstance
return ValueSet([ return ValueSet([
CompiledInstance(self.infer_state, self.parent_value, self, arguments) CompiledInstance(self.infer_state, self.parent_context, self, arguments)
]) ])
else: else:
return ValueSet(self._execute_function(arguments)) return ValueSet(self._execute_function(arguments))
@@ -269,18 +269,18 @@ class CompiledObject(Value):
class CompiledName(AbstractNameDefinition): class CompiledName(AbstractNameDefinition):
def __init__(self, infer_state, parent_value, name): def __init__(self, infer_state, parent_context, name):
self._infer_state = infer_state self._infer_state = infer_state
self.parent_value = parent_value self.parent_context = parent_context
self.string_name = name self.string_name = name
def _get_qualified_names(self): def _get_qualified_names(self):
parent_qualified_names = self.parent_value.get_qualified_names() parent_qualified_names = self.parent_context.get_qualified_names()
return parent_qualified_names + (self.string_name,) return parent_qualified_names + (self.string_name,)
def __repr__(self): def __repr__(self):
try: try:
name = self.parent_value.name # __name__ is not defined all the time name = self.parent_context.name # __name__ is not defined all the time
except AttributeError: except AttributeError:
name = None name = None
return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name) return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name)
@@ -296,13 +296,13 @@ class CompiledName(AbstractNameDefinition):
@underscore_memoization @underscore_memoization
def infer(self): def infer(self):
return ValueSet([_create_from_name( return ValueSet([_create_from_name(
self._infer_state, self.parent_value, self.string_name self._infer_state, self.parent_context, self.string_name
)]) )])
class SignatureParamName(ParamNameInterface, AbstractNameDefinition): class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
def __init__(self, compiled_obj, signature_param): def __init__(self, compiled_obj, signature_param):
self.parent_value = compiled_obj.parent_value self.parent_context = compiled_obj.parent_context
self._signature_param = signature_param self._signature_param = signature_param
@property @property
@@ -322,7 +322,7 @@ class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
def infer(self): def infer(self):
p = self._signature_param p = self._signature_param
infer_state = self.parent_value.infer_state infer_state = self.parent_context.infer_state
values = NO_VALUES values = NO_VALUES
if p.has_default: if p.has_default:
values = ValueSet([create_from_access_path(infer_state, p.default)]) values = ValueSet([create_from_access_path(infer_state, p.default)])
@@ -334,7 +334,7 @@ class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition): class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition):
def __init__(self, compiled_obj, name, default): def __init__(self, compiled_obj, name, default):
self.parent_value = compiled_obj.parent_value self.parent_context = compiled_obj.parent_context
self.string_name = name self.string_name = name
self._default = default self._default = default
@@ -355,7 +355,7 @@ class CompiledValueName(ValueNameMixin, AbstractNameDefinition):
def __init__(self, value, name): def __init__(self, value, name):
self.string_name = name self.string_name = name
self._value = value self._value = value
self.parent_value = value.parent_value self.parent_context = value.parent_context
class EmptyCompiledName(AbstractNameDefinition): class EmptyCompiledName(AbstractNameDefinition):
@@ -365,7 +365,7 @@ class EmptyCompiledName(AbstractNameDefinition):
nothing. nothing.
""" """
def __init__(self, infer_state, name): def __init__(self, infer_state, name):
self.parent_value = infer_state.builtins_module self.parent_context = infer_state.builtins_module
self.string_name = name self.string_name = name
def infer(self): def infer(self):
@@ -509,33 +509,33 @@ def _parse_function_doc(doc):
def _create_from_name(infer_state, compiled_object, name): def _create_from_name(infer_state, compiled_object, name):
access_paths = compiled_object.access_handle.getattr_paths(name, default=None) access_paths = compiled_object.access_handle.getattr_paths(name, default=None)
parent_value = compiled_object parent_context = compiled_object
if parent_value.is_class(): if parent_context.is_class():
parent_value = parent_value.parent_value parent_context = parent_context.parent_context
value = None value = None
for access_path in access_paths: for access_path in access_paths:
value = create_cached_compiled_object( value = create_cached_compiled_object(
infer_state, access_path, parent_value=value infer_state, access_path, parent_context=value
) )
return value return value
def _normalize_create_args(func): def _normalize_create_args(func):
"""The cache doesn't care about keyword vs. normal args.""" """The cache doesn't care about keyword vs. normal args."""
def wrapper(infer_state, obj, parent_value=None): def wrapper(infer_state, obj, parent_context=None):
return func(infer_state, obj, parent_value) return func(infer_state, obj, parent_context)
return wrapper return wrapper
def create_from_access_path(infer_state, access_path): def create_from_access_path(infer_state, access_path):
parent_value = None parent_context = None
for name, access in access_path.accesses: for name, access in access_path.accesses:
parent_value = create_cached_compiled_object(infer_state, access, parent_value) parent_context = create_cached_compiled_object(infer_state, access, parent_context)
return parent_value return parent_context
@_normalize_create_args @_normalize_create_args
@infer_state_function_cache() @infer_state_function_cache()
def create_cached_compiled_object(infer_state, access_handle, parent_value): def create_cached_compiled_object(infer_state, access_handle, parent_context):
return CompiledObject(infer_state, access_handle, parent_value) return CompiledObject(infer_state, access_handle, parent_context)
jedi/inference/dynamic.py
+3 -3
View File
@@ -189,7 +189,7 @@ def _check_name_for_execution(infer_state, value, compare_node, name, trailer):
if value_node.type == 'classdef': if value_node.type == 'classdef':
created_instance = instance.TreeInstance( created_instance = instance.TreeInstance(
infer_state, infer_state,
v.parent_value, v.parent_context,
v, v,
args args
) )
@@ -203,12 +203,12 @@ def _check_name_for_execution(infer_state, value, compare_node, name, trailer):
if compare_node == value_node: if compare_node == value_node:
for func_execution in create_func_excs(): for func_execution in create_func_excs():
yield func_execution yield func_execution
elif isinstance(v.parent_value, FunctionExecutionValue) and \ elif isinstance(v.parent_context, FunctionExecutionValue) and \
compare_node.type == 'funcdef': compare_node.type == 'funcdef':
# Here we're trying to find decorators by checking the first # Here we're trying to find decorators by checking the first
# parameter. It's not very generic though. Should find a better # parameter. It's not very generic though. Should find a better
# solution that also applies to nested decorators. # solution that also applies to nested decorators.
params, _ = v.parent_value.get_executed_params_and_issues() params, _ = v.parent_context.get_executed_params_and_issues()
if len(params) != 1: if len(params) != 1:
continue continue
values = params[0].infer() values = params[0].infer()
jedi/inference/filters.py
+7 -7
View File
@@ -238,14 +238,14 @@ class _BuiltinMappedMethod(Value):
def __init__(self, builtin_value, method, builtin_func): def __init__(self, builtin_value, method, builtin_func):
super(_BuiltinMappedMethod, self).__init__( super(_BuiltinMappedMethod, self).__init__(
builtin_value.infer_state, builtin_value.infer_state,
parent_value=builtin_value parent_context=builtin_value
) )
self._method = method self._method = method
self._builtin_func = builtin_func self._builtin_func = builtin_func
def py__call__(self, arguments): def py__call__(self, arguments):
# TODO add TypeError if params are given/or not correct. # TODO add TypeError if params are given/or not correct.
return self._method(self.parent_value) return self._method(self.parent_context)
def __getattr__(self, name): def __getattr__(self, name):
return getattr(self._builtin_func, name) return getattr(self._builtin_func, name)
@@ -259,13 +259,13 @@ class SpecialMethodFilter(DictFilter):
class SpecialMethodName(AbstractNameDefinition): class SpecialMethodName(AbstractNameDefinition):
api_type = u'function' api_type = u'function'
def __init__(self, parent_value, string_name, value, builtin_value): def __init__(self, parent_context, string_name, value, builtin_value):
callable_, python_version = value callable_, python_version = value
if python_version is not None and \ if python_version is not None and \
python_version != parent_value.infer_state.environment.version_info.major: python_version != parent_context.infer_state.environment.version_info.major:
raise KeyError raise KeyError
self.parent_value = parent_value self.parent_context = parent_context
self.string_name = string_name self.string_name = string_name
self._callable = callable_ self._callable = callable_
self._builtin_value = builtin_value self._builtin_value = builtin_value
@@ -282,7 +282,7 @@ class SpecialMethodFilter(DictFilter):
continue continue
break break
return ValueSet([ return ValueSet([
_BuiltinMappedMethod(self.parent_value, self._callable, builtin_func) _BuiltinMappedMethod(self.parent_context, self._callable, builtin_func)
]) ])
def __init__(self, value, dct, builtin_value): def __init__(self, value, dct, builtin_value):
@@ -406,7 +406,7 @@ def get_global_filters(infer_state, value, until_position, origin_scope):
# The position should be reset if the current scope is a function. # The position should be reset if the current scope is a function.
until_position = None until_position = None
value = value.parent_value value = value.parent_context
# Add builtins to the global scope. # Add builtins to the global scope.
yield next(infer_state.builtins_module.get_filters()) yield next(infer_state.builtins_module.get_filters())
jedi/inference/gradual/typing.py
+25 -25
View File
@@ -37,7 +37,7 @@ _PROXY_TYPES = 'Optional Union ClassVar'.split()
class TypingName(AbstractTreeName): class TypingName(AbstractTreeName):
def __init__(self, value, other_name): def __init__(self, value, other_name):
super(TypingName, self).__init__(value.parent_value, other_name.tree_name) super(TypingName, self).__init__(value.parent_context, other_name.tree_name)
self._value = value self._value = value
def infer(self): def infer(self):
@@ -45,8 +45,8 @@ class TypingName(AbstractTreeName):
class _BaseTypingValue(Value): class _BaseTypingValue(Value):
def __init__(self, infer_state, parent_value, tree_name): def __init__(self, infer_state, parent_context, tree_name):
super(_BaseTypingValue, self).__init__(infer_state, parent_value) super(_BaseTypingValue, self).__init__(infer_state, parent_context)
self._tree_name = tree_name self._tree_name = tree_name
@property @property
@@ -87,39 +87,39 @@ class TypingModuleName(NameWrapper):
def _remap(self): def _remap(self):
name = self.string_name name = self.string_name
infer_state = self.parent_value.infer_state infer_state = self.parent_context.infer_state
try: try:
actual = _TYPE_ALIAS_TYPES[name] actual = _TYPE_ALIAS_TYPES[name]
except KeyError: except KeyError:
pass pass
else: else:
yield TypeAlias.create_cached(infer_state, self.parent_value, self.tree_name, actual) yield TypeAlias.create_cached(infer_state, self.parent_context, self.tree_name, actual)
return return
if name in _PROXY_CLASS_TYPES: if name in _PROXY_CLASS_TYPES:
yield TypingClassValue.create_cached(infer_state, self.parent_value, self.tree_name) yield TypingClassValue.create_cached(infer_state, self.parent_context, self.tree_name)
elif name in _PROXY_TYPES: elif name in _PROXY_TYPES:
yield TypingValue.create_cached(infer_state, self.parent_value, self.tree_name) yield TypingValue.create_cached(infer_state, self.parent_context, self.tree_name)
elif name == 'runtime': elif name == 'runtime':
# We don't want anything here, not sure what this function is # 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 # supposed to do, since it just appears in the stubs and shouldn't
# have any effects there (because it's never executed). # have any effects there (because it's never executed).
return return
elif name == 'TypeVar': elif name == 'TypeVar':
yield TypeVarClass.create_cached(infer_state, self.parent_value, self.tree_name) yield TypeVarClass.create_cached(infer_state, self.parent_context, self.tree_name)
elif name == 'Any': elif name == 'Any':
yield Any.create_cached(infer_state, self.parent_value, self.tree_name) yield Any.create_cached(infer_state, self.parent_context, self.tree_name)
elif name == 'TYPE_CHECKING': elif name == 'TYPE_CHECKING':
# This is needed for e.g. imports that are only available for type # This is needed for e.g. imports that are only available for type
# checking or are in cycles. The user can then check this variable. # checking or are in cycles. The user can then check this variable.
yield builtin_from_name(infer_state, u'True') yield builtin_from_name(infer_state, u'True')
elif name == 'overload': elif name == 'overload':
yield OverloadFunction.create_cached(infer_state, self.parent_value, self.tree_name) yield OverloadFunction.create_cached(infer_state, self.parent_context, self.tree_name)
elif name == 'NewType': elif name == 'NewType':
yield NewTypeFunction.create_cached(infer_state, self.parent_value, self.tree_name) yield NewTypeFunction.create_cached(infer_state, self.parent_context, self.tree_name)
elif name == 'cast': elif name == 'cast':
# TODO implement cast # TODO implement cast
yield CastFunction.create_cached(infer_state, self.parent_value, self.tree_name) yield CastFunction.create_cached(infer_state, self.parent_context, self.tree_name)
elif name == 'TypedDict': elif name == 'TypedDict':
# TODO doesn't even exist in typeshed/typing.py, yet. But will be # TODO doesn't even exist in typeshed/typing.py, yet. But will be
# added soon. # added soon.
@@ -139,8 +139,8 @@ class TypingModuleFilterWrapper(FilterWrapper):
class _WithIndexBase(_BaseTypingValue): class _WithIndexBase(_BaseTypingValue):
def __init__(self, infer_state, parent_value, name, index_value, value_of_index): def __init__(self, infer_state, parent_context, name, index_value, value_of_index):
super(_WithIndexBase, self).__init__(infer_state, parent_value, name) super(_WithIndexBase, self).__init__(infer_state, parent_context, name)
self._index_value = index_value self._index_value = index_value
self._value_of_index = value_of_index self._value_of_index = value_of_index
@@ -175,7 +175,7 @@ class TypingValueWithIndex(_WithIndexBase):
cls = globals()[string_name] cls = globals()[string_name]
return ValueSet([cls( return ValueSet([cls(
self.infer_state, self.infer_state,
self.parent_value, self.parent_context,
self._tree_name, self._tree_name,
self._index_value, self._index_value,
self._value_of_index self._value_of_index
@@ -195,7 +195,7 @@ class TypingValue(_BaseTypingValue):
return ValueSet( return ValueSet(
self.index_class.create_cached( self.index_class.create_cached(
self.infer_state, self.infer_state,
self.parent_value, self.parent_context,
self._tree_name, self._tree_name,
index_value, index_value,
value_of_index=valueualized_node.value) value_of_index=valueualized_node.value)
@@ -245,9 +245,9 @@ def _iter_over_arguments(maybe_tuple_value, defining_value):
class TypeAlias(LazyValueWrapper): class TypeAlias(LazyValueWrapper):
def __init__(self, parent_value, origin_tree_name, actual): def __init__(self, parent_context, origin_tree_name, actual):
self.infer_state = parent_value.infer_state self.infer_state = parent_context.infer_state
self.parent_value = parent_value self.parent_context = parent_context
self._origin_tree_name = origin_tree_name self._origin_tree_name = origin_tree_name
self._actual = actual # e.g. builtins.list self._actual = actual # e.g. builtins.list
@@ -359,7 +359,7 @@ class TypeVarClass(_BaseTypingValue):
return ValueSet([TypeVar.create_cached( return ValueSet([TypeVar.create_cached(
self.infer_state, self.infer_state,
self.parent_value, self.parent_context,
self._tree_name, self._tree_name,
var_name, var_name,
unpacked unpacked
@@ -391,8 +391,8 @@ class TypeVarClass(_BaseTypingValue):
class TypeVar(_BaseTypingValue): class TypeVar(_BaseTypingValue):
def __init__(self, infer_state, parent_value, tree_name, var_name, unpacked_args): def __init__(self, infer_state, parent_context, tree_name, var_name, unpacked_args):
super(TypeVar, self).__init__(infer_state, parent_value, tree_name) super(TypeVar, self).__init__(infer_state, parent_context, tree_name)
self._var_name = var_name self._var_name = var_name
self._constraints_lazy_values = [] self._constraints_lazy_values = []
@@ -477,8 +477,8 @@ class NewTypeFunction(_BaseTypingValue):
class NewType(Value): class NewType(Value):
def __init__(self, infer_state, parent_value, tree_node, type_value_set): def __init__(self, infer_state, parent_context, tree_node, type_value_set):
super(NewType, self).__init__(infer_state, parent_value) super(NewType, self).__init__(infer_state, parent_context)
self._type_value_set = type_value_set self._type_value_set = type_value_set
self.tree_node = tree_node self.tree_node = tree_node
@@ -498,7 +498,7 @@ class BoundTypeVarName(AbstractNameDefinition):
""" """
def __init__(self, type_var, value_set): def __init__(self, type_var, value_set):
self._type_var = type_var self._type_var = type_var
self.parent_value = type_var.parent_value self.parent_context = type_var.parent_context
self._value_set = value_set self._value_set = value_set
def infer(self): def infer(self):
jedi/inference/names.py
+17 -17
View File
@@ -10,7 +10,7 @@ from jedi.cache import memoize_method
class AbstractNameDefinition(object): class AbstractNameDefinition(object):
start_pos = None start_pos = None
string_name = None string_name = None
parent_value = None parent_context = None
tree_name = None tree_name = None
is_value_name = True is_value_name = True
""" """
@@ -42,7 +42,7 @@ class AbstractNameDefinition(object):
return None return None
def get_root_value(self): def get_root_value(self):
return self.parent_value.get_root_value() return self.parent_context.get_root_value()
def __repr__(self): def __repr__(self):
if self.start_pos is None: if self.start_pos is None:
@@ -55,7 +55,7 @@ class AbstractNameDefinition(object):
@property @property
def api_type(self): def api_type(self):
return self.parent_value.api_type return self.parent_context.api_type
class AbstractArbitraryName(AbstractNameDefinition): class AbstractArbitraryName(AbstractNameDefinition):
@@ -69,15 +69,15 @@ class AbstractArbitraryName(AbstractNameDefinition):
def __init__(self, infer_state, string): def __init__(self, infer_state, string):
self.infer_state = infer_state self.infer_state = infer_state
self.string_name = string self.string_name = string
self.parent_value = infer_state.builtins_module self.parent_context = infer_state.builtins_module
def infer(self): def infer(self):
return NO_VALUES return NO_VALUES
class AbstractTreeName(AbstractNameDefinition): class AbstractTreeName(AbstractNameDefinition):
def __init__(self, parent_value, tree_name): def __init__(self, parent_context, tree_name):
self.parent_value = parent_value self.parent_context = parent_context
self.tree_name = tree_name self.tree_name = tree_name
def get_qualified_names(self, include_module_names=False): def get_qualified_names(self, include_module_names=False):
@@ -97,13 +97,13 @@ class AbstractTreeName(AbstractNameDefinition):
return super(AbstractTreeName, self).get_qualified_names(include_module_names) return super(AbstractTreeName, self).get_qualified_names(include_module_names)
def _get_qualified_names(self): def _get_qualified_names(self):
parent_names = self.parent_value.get_qualified_names() parent_names = self.parent_context.get_qualified_names()
if parent_names is None: if parent_names is None:
return None return None
return parent_names + (self.tree_name.value,) return parent_names + (self.tree_name.value,)
def goto(self, **kwargs): def goto(self, **kwargs):
return self.parent_value.infer_state.goto(self.parent_value, self.tree_name, **kwargs) return self.parent_context.infer_state.goto(self.parent_context, self.tree_name, **kwargs)
def is_import(self): def is_import(self):
imp = search_ancestor(self.tree_name, 'import_from', 'import_name') imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
@@ -126,7 +126,7 @@ class ValueNameMixin(object):
return self._value.get_qualified_names() return self._value.get_qualified_names()
def get_root_value(self): def get_root_value(self):
if self.parent_value is None: # A module if self.parent_context is None: # A module
return self._value return self._value
return super(ValueNameMixin, self).get_root_value() return super(ValueNameMixin, self).get_root_value()
@@ -137,7 +137,7 @@ class ValueNameMixin(object):
class ValueName(ValueNameMixin, AbstractTreeName): class ValueName(ValueNameMixin, AbstractTreeName):
def __init__(self, value, tree_name): def __init__(self, value, tree_name):
super(ValueName, self).__init__(value.parent_value, tree_name) super(ValueName, self).__init__(value.parent_context, tree_name)
self._value = value self._value = value
def goto(self): def goto(self):
@@ -156,7 +156,7 @@ class TreeNameDefinition(AbstractTreeName):
def infer(self): def infer(self):
# Refactor this, should probably be here. # Refactor this, should probably be here.
from jedi.inference.syntax_tree import tree_name_to_values from jedi.inference.syntax_tree import tree_name_to_values
parent = self.parent_value parent = self.parent_context
return tree_name_to_values(parent.infer_state, parent, self.tree_name) return tree_name_to_values(parent.infer_state, parent, self.tree_name)
@property @property
@@ -241,7 +241,7 @@ class ParamName(BaseTreeParamName):
node = self.annotation_node node = self.annotation_node
if node is None: if node is None:
return NO_VALUES return NO_VALUES
values = self.parent_value.parent_value.infer_node(node) values = self.parent_context.parent_context.infer_node(node)
if execute_annotation: if execute_annotation:
values = values.execute_annotation() values = values.execute_annotation()
return values return values
@@ -250,7 +250,7 @@ class ParamName(BaseTreeParamName):
node = self.default_node node = self.default_node
if node is None: if node is None:
return NO_VALUES return NO_VALUES
return self.parent_value.parent_value.infer_node(node) return self.parent_context.parent_context.infer_node(node)
@property @property
def default_node(self): def default_node(self):
@@ -297,7 +297,7 @@ class ParamName(BaseTreeParamName):
return self.get_param().infer() return self.get_param().infer()
def get_param(self): def get_param(self):
params, _ = self.parent_value.get_executed_params_and_issues() params, _ = self.parent_context.get_executed_params_and_issues()
param_node = search_ancestor(self.tree_name, 'param') param_node = search_ancestor(self.tree_name, 'param')
return params[param_node.position_index] return params[param_node.position_index]
@@ -317,8 +317,8 @@ class ImportName(AbstractNameDefinition):
start_pos = (1, 0) start_pos = (1, 0)
_level = 0 _level = 0
def __init__(self, parent_value, string_name): def __init__(self, parent_context, string_name):
self._from_module_value = parent_value self._from_module_value = parent_context
self.string_name = string_name self.string_name = string_name
def get_qualified_names(self, include_module_names=False): def get_qualified_names(self, include_module_names=False):
@@ -333,7 +333,7 @@ class ImportName(AbstractNameDefinition):
return () return ()
@property @property
def parent_value(self): def parent_context(self):
m = self._from_module_value m = self._from_module_value
import_values = self.infer() import_values = self.infer()
if not import_values: if not import_values:
jedi/inference/param.py
+1 -1
View File
@@ -244,7 +244,7 @@ def _create_default_param(execution_value, param):
elif param.default is None: elif param.default is None:
result_arg = LazyUnknownValue() result_arg = LazyUnknownValue()
else: else:
result_arg = LazyTreeValue(execution_value.parent_value, param.default) result_arg = LazyTreeValue(execution_value.parent_context, param.default)
return ExecutedParam(execution_value, param, result_arg) return ExecutedParam(execution_value, param, result_arg)
jedi/inference/star_args.py
+2 -2
View File
@@ -20,7 +20,7 @@ def _iter_nodes_for_param(param_name):
from parso.python.tree import search_ancestor from parso.python.tree import search_ancestor
from jedi.inference.arguments import TreeArguments from jedi.inference.arguments import TreeArguments
execution_value = param_name.parent_value execution_value = param_name.parent_context
function_node = execution_value.tree_node function_node = execution_value.tree_node
module_node = function_node.get_root_node() module_node = function_node.get_root_node()
start = function_node.children[-1].start_pos start = function_node.children[-1].start_pos
@@ -56,7 +56,7 @@ def _goes_to_param_name(param_name, value, potential_name):
return False return False
from jedi.inference.names import TreeNameDefinition from jedi.inference.names import TreeNameDefinition
found = TreeNameDefinition(value, potential_name).goto() found = TreeNameDefinition(value, potential_name).goto()
return any(param_name.parent_value == p.parent_value return any(param_name.parent_context == p.parent_context
and param_name.start_pos == p.start_pos and param_name.start_pos == p.start_pos
for p in found) for p in found)
jedi/inference/syntax_tree.py
+1 -1
View File
@@ -637,7 +637,7 @@ def _apply_decorators(value, node):
if node.type == 'classdef': if node.type == 'classdef':
decoratee_value = ClassValue( decoratee_value = ClassValue(
value.infer_state, value.infer_state,
parent_value=value, parent_context=value,
tree_node=node tree_node=node
) )
else: else:
jedi/inference/value/function.py
+13 -13
View File
@@ -28,7 +28,7 @@ class LambdaName(AbstractNameDefinition):
def __init__(self, lambda_value): def __init__(self, lambda_value):
self._lambda_value = lambda_value self._lambda_value = lambda_value
self.parent_value = lambda_value.parent_value self.parent_context = lambda_value.parent_context
@property @property
def start_pos(self): def start_pos(self):
@@ -40,13 +40,13 @@ class LambdaName(AbstractNameDefinition):
class FunctionAndClassBase(TreeValue): class FunctionAndClassBase(TreeValue):
def get_qualified_names(self): def get_qualified_names(self):
if self.parent_value.is_class(): if self.parent_context.is_class():
n = self.parent_value.get_qualified_names() n = self.parent_context.get_qualified_names()
if n is None: if n is None:
# This means that the parent class lives within a function. # This means that the parent class lives within a function.
return None return None
return n + (self.py__name__(),) return n + (self.py__name__(),)
elif self.parent_value.is_module(): elif self.parent_context.is_module():
return (self.py__name__(),) return (self.py__name__(),)
else: else:
return None return None
@@ -98,7 +98,7 @@ class FunctionMixin(object):
if arguments is None: if arguments is None:
arguments = AnonymousArguments() arguments = AnonymousArguments()
return FunctionExecutionValue(self.infer_state, self.parent_value, self, arguments) return FunctionExecutionValue(self.infer_state, self.parent_context, self, arguments)
def get_signatures(self): def get_signatures(self):
return [TreeSignature(f) for f in self.get_signature_functions()] return [TreeSignature(f) for f in self.get_signature_functions()]
@@ -115,21 +115,21 @@ class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndCla
return MethodValue( return MethodValue(
value.infer_state, value.infer_state,
value, value,
parent_value=parent_value, parent_context=parent_context,
tree_node=tree_node tree_node=tree_node
) )
else: else:
return cls( return cls(
value.infer_state, value.infer_state,
parent_value=parent_value, parent_context=parent_context,
tree_node=tree_node tree_node=tree_node
) )
overloaded_funcs = list(_find_overload_functions(value, tree_node)) overloaded_funcs = list(_find_overload_functions(value, tree_node))
parent_value = value parent_context = value
while parent_value.is_class() or parent_value.is_instance(): while parent_context.is_class() or parent_context.is_instance():
parent_value = parent_value.parent_value parent_context = parent_context.parent_context
function = create(tree_node) function = create(tree_node)
@@ -145,7 +145,7 @@ class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndCla
return c return c
def get_default_param_value(self): def get_default_param_value(self):
return self.parent_value return self.parent_context
def get_signature_functions(self): def get_signature_functions(self):
return [self] return [self]
@@ -171,10 +171,10 @@ class MethodValue(FunctionValue):
class FunctionExecutionValue(TreeValue): class FunctionExecutionValue(TreeValue):
function_execution_filter = FunctionExecutionFilter function_execution_filter = FunctionExecutionFilter
def __init__(self, infer_state, parent_value, function_value, var_args): def __init__(self, infer_state, parent_context, function_value, var_args):
super(FunctionExecutionValue, self).__init__( super(FunctionExecutionValue, self).__init__(
infer_state, infer_state,
parent_value, parent_context,
function_value.tree_node, function_value.tree_node,
) )
self.function_value = function_value self.function_value = function_value
jedi/inference/value/instance.py
+17 -17
View File
@@ -61,8 +61,8 @@ class AnonymousInstanceArguments(AnonymousArguments):
class AbstractInstanceValue(Value): class AbstractInstanceValue(Value):
api_type = u'instance' api_type = u'instance'
def __init__(self, infer_state, parent_value, class_value, var_args): def __init__(self, infer_state, parent_context, class_value, var_args):
super(AbstractInstanceValue, self).__init__(infer_state, parent_value) super(AbstractInstanceValue, self).__init__(infer_state, parent_context)
# Generated instances are classes that are just generated by self # Generated instances are classes that are just generated by self
# (No var_args) used. # (No var_args) used.
self.class_value = class_value self.class_value = class_value
@@ -193,7 +193,7 @@ class AbstractInstanceValue(Value):
# TODO is this correct? I think we need to check for functions. # TODO is this correct? I think we need to check for functions.
if isinstance(name, LazyInstanceClassName): if isinstance(name, LazyInstanceClassName):
function = FunctionValue.from_value( function = FunctionValue.from_value(
self.parent_value, self.parent_context,
name.tree_name.parent name.tree_name.parent
) )
bound_method = BoundMethod(self, function) bound_method = BoundMethod(self, function)
@@ -207,19 +207,19 @@ class AbstractInstanceValue(Value):
if scope == class_value.tree_node: if scope == class_value.tree_node:
return class_value return class_value
else: else:
parent_value = self.create_instance_value(class_value, scope) parent_context = self.create_instance_value(class_value, scope)
if scope.type == 'funcdef': if scope.type == 'funcdef':
func = FunctionValue.from_value( func = FunctionValue.from_value(
parent_value, parent_context,
scope, scope,
) )
bound_method = BoundMethod(self, func) bound_method = BoundMethod(self, func)
if scope.name.value == '__init__' and parent_value == class_value: if scope.name.value == '__init__' and parent_context == class_value:
return bound_method.get_function_execution(self.var_args) return bound_method.get_function_execution(self.var_args)
else: else:
return bound_method.get_function_execution() return bound_method.get_function_execution()
elif scope.type == 'classdef': elif scope.type == 'classdef':
class_value = ClassValue(self.infer_state, parent_value, scope) class_value = ClassValue(self.infer_state, parent_context, scope)
return class_value return class_value
elif scope.type in ('comp_for', 'sync_comp_for'): elif scope.type in ('comp_for', 'sync_comp_for'):
# Comprehensions currently don't have a special scope in Jedi. # Comprehensions currently don't have a special scope in Jedi.
@@ -238,9 +238,9 @@ class AbstractInstanceValue(Value):
class CompiledInstance(AbstractInstanceValue): class CompiledInstance(AbstractInstanceValue):
def __init__(self, infer_state, parent_value, class_value, var_args): def __init__(self, infer_state, parent_context, class_value, var_args):
self._original_var_args = var_args self._original_var_args = var_args
super(CompiledInstance, self).__init__(infer_state, parent_value, class_value, var_args) super(CompiledInstance, self).__init__(infer_state, parent_context, class_value, var_args)
@property @property
def name(self): def name(self):
@@ -258,16 +258,16 @@ class CompiledInstance(AbstractInstanceValue):
class TreeInstance(AbstractInstanceValue): class TreeInstance(AbstractInstanceValue):
def __init__(self, infer_state, parent_value, class_value, var_args): def __init__(self, infer_state, parent_context, class_value, var_args):
# I don't think that dynamic append lookups should happen here. That # I don't think that dynamic append lookups should happen here. That
# sounds more like something that should go to py__iter__. # sounds more like something that should go to py__iter__.
if class_value.py__name__() in ['list', 'set'] \ if class_value.py__name__() in ['list', 'set'] \
and parent_value.get_root_value() == infer_state.builtins_module: and parent_context.get_root_value() == infer_state.builtins_module:
# compare the module path with the builtin name. # compare the module path with the builtin name.
if settings.dynamic_array_additions: if settings.dynamic_array_additions:
var_args = iterable.get_dynamic_array_instance(self, var_args) var_args = iterable.get_dynamic_array_instance(self, var_args)
super(TreeInstance, self).__init__(infer_state, parent_value, super(TreeInstance, self).__init__(infer_state, parent_context,
class_value, var_args) class_value, var_args)
self.tree_node = class_value.tree_node self.tree_node = class_value.tree_node
@@ -313,10 +313,10 @@ class TreeInstance(AbstractInstanceValue):
class AnonymousInstance(TreeInstance): class AnonymousInstance(TreeInstance):
def __init__(self, infer_state, parent_value, class_value): def __init__(self, infer_state, parent_context, class_value):
super(AnonymousInstance, self).__init__( super(AnonymousInstance, self).__init__(
infer_state, infer_state,
parent_value, parent_context,
class_value, class_value,
var_args=AnonymousInstanceArguments(self), var_args=AnonymousInstanceArguments(self),
) )
@@ -330,7 +330,7 @@ class CompiledInstanceName(compiled.CompiledName):
def __init__(self, infer_state, instance, klass, name): def __init__(self, infer_state, instance, klass, name):
super(CompiledInstanceName, self).__init__( super(CompiledInstanceName, self).__init__(
infer_state, infer_state,
klass.parent_value, klass.parent_context,
name.string_name name.string_name
) )
self._instance = instance self._instance = instance
@@ -419,7 +419,7 @@ class CompiledBoundMethod(ValueWrapper):
class SelfName(TreeNameDefinition): class SelfName(TreeNameDefinition):
""" """
This name calculates the parent_value lazily. This name calculates the parent_context lazily.
""" """
def __init__(self, instance, class_value, tree_name): def __init__(self, instance, class_value, tree_name):
self._instance = instance self._instance = instance
@@ -427,7 +427,7 @@ class SelfName(TreeNameDefinition):
self.tree_name = tree_name self.tree_name = tree_name
@property @property
def parent_value(self): def parent_context(self):
return self._instance.create_instance_value(self.class_value, self.tree_name) return self._instance.create_instance_value(self.class_value, self.tree_name)
jedi/inference/value/iterable.py
+10 -10
View File
@@ -113,8 +113,8 @@ class Generator(GeneratorBase):
class CompForValue(TreeValue): class CompForValue(TreeValue):
@classmethod @classmethod
def from_comp_for(cls, parent_value, comp_for): def from_comp_for(cls, parent_context, comp_for):
return cls(parent_value.infer_state, parent_value, comp_for) return cls(parent_context.infer_state, parent_context, comp_for)
def get_filters(self, search_global=False, until_position=None, origin_scope=None): def get_filters(self, search_global=False, until_position=None, origin_scope=None):
yield ParserTreeFilter(self.infer_state, self) yield ParserTreeFilter(self.infer_state, self)
@@ -158,27 +158,27 @@ def comprehension_from_atom(infer_state, value, atom):
class ComprehensionMixin(object): class ComprehensionMixin(object):
@infer_state_method_cache() @infer_state_method_cache()
def _get_comp_for_value(self, parent_value, comp_for): def _get_comp_for_value(self, parent_context, comp_for):
return CompForValue.from_comp_for(parent_value, comp_for) return CompForValue.from_comp_for(parent_context, comp_for)
def _nested(self, comp_fors, parent_value=None): def _nested(self, comp_fors, parent_context=None):
comp_for = comp_fors[0] comp_for = comp_fors[0]
is_async = comp_for.parent.type == 'comp_for' is_async = comp_for.parent.type == 'comp_for'
input_node = comp_for.children[3] input_node = comp_for.children[3]
parent_value = parent_value or self._defining_value parent_context = parent_context or self._defining_value
input_types = parent_value.infer_node(input_node) input_types = parent_context.infer_node(input_node)
# TODO: simulate await if self.is_async # TODO: simulate await if self.is_async
cn = ValueualizedNode(parent_value, input_node) cn = ValueualizedNode(parent_context, input_node)
iterated = input_types.iterate(cn, is_async=is_async) iterated = input_types.iterate(cn, is_async=is_async)
exprlist = comp_for.children[1] exprlist = comp_for.children[1]
for i, lazy_value in enumerate(iterated): for i, lazy_value in enumerate(iterated):
types = lazy_value.infer() types = lazy_value.infer()
dct = unpack_tuple_to_dict(parent_value, types, exprlist) dct = unpack_tuple_to_dict(parent_context, types, exprlist)
value_ = self._get_comp_for_value( value_ = self._get_comp_for_value(
parent_value, parent_context,
comp_for, comp_for,
) )
with predefine_names(value_, comp_for, dct): with predefine_names(value_, comp_for, dct):
jedi/inference/value/klass.py
+9 -9
View File
@@ -63,8 +63,8 @@ def apply_py__get__(value, instance, class_value):
class ClassName(TreeNameDefinition): class ClassName(TreeNameDefinition):
def __init__(self, parent_value, tree_name, name_value, apply_decorators): def __init__(self, parent_context, tree_name, name_value, apply_decorators):
super(ClassName, self).__init__(parent_value, tree_name) super(ClassName, self).__init__(parent_context, tree_name)
self._name_value = name_value self._name_value = name_value
self._apply_decorators = apply_decorators self._apply_decorators = apply_decorators
@@ -73,13 +73,13 @@ class ClassName(TreeNameDefinition):
# We're using a different value to infer, so we cannot call super(). # We're using a different value to infer, so we cannot call super().
from jedi.inference.syntax_tree import tree_name_to_values from jedi.inference.syntax_tree import tree_name_to_values
inferred = tree_name_to_values( inferred = tree_name_to_values(
self.parent_value.infer_state, self._name_value, self.tree_name) self.parent_context.infer_state, self._name_value, self.tree_name)
for result_value in inferred: for result_value in inferred:
if self._apply_decorators: if self._apply_decorators:
for c in apply_py__get__(result_value, for c in apply_py__get__(result_value,
instance=None, instance=None,
class_value=self.parent_value): class_value=self.parent_context):
yield c yield c
else: else:
yield result_value yield result_value
@@ -95,7 +95,7 @@ class ClassFilter(ParserTreeFilter):
def _convert_names(self, names): def _convert_names(self, names):
return [ return [
self.name_class( self.name_class(
parent_value=self.value, parent_context=self.value,
tree_name=name, tree_name=name,
name_value=self._node_value, name_value=self._node_value,
apply_decorators=not self._is_instance, apply_decorators=not self._is_instance,
@@ -141,7 +141,7 @@ class ClassMixin(object):
from jedi.inference.value import TreeInstance from jedi.inference.value import TreeInstance
if arguments is None: if arguments is None:
arguments = ValuesArguments([]) arguments = ValuesArguments([])
return ValueSet([TreeInstance(self.infer_state, self.parent_value, self, arguments)]) return ValueSet([TreeInstance(self.infer_state, self.parent_context, self, arguments)])
def py__class__(self): def py__class__(self):
return compiled.builtin_from_name(self.infer_state, u'type') return compiled.builtin_from_name(self.infer_state, u'type')
@@ -252,7 +252,7 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
continue # These are not relevant for this search. continue # These are not relevant for this search.
from jedi.inference.gradual.annotation import find_unknown_type_vars from jedi.inference.gradual.annotation import find_unknown_type_vars
for type_var in find_unknown_type_vars(self.parent_value, node): for type_var in find_unknown_type_vars(self.parent_context, node):
if type_var not in found: if type_var not in found:
# The order matters and it's therefore a list. # The order matters and it's therefore a list.
found.append(type_var) found.append(type_var)
@@ -262,7 +262,7 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
arglist = self.tree_node.get_super_arglist() arglist = self.tree_node.get_super_arglist()
if arglist: if arglist:
from jedi.inference import arguments from jedi.inference import arguments
return arguments.TreeArguments(self.infer_state, self.parent_value, arglist) return arguments.TreeArguments(self.infer_state, self.parent_context, arglist)
return None return None
@infer_state_method_cache(default=()) @infer_state_method_cache(default=())
@@ -274,7 +274,7 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
return lst return lst
if self.py__name__() == 'object' \ if self.py__name__() == 'object' \
and self.parent_value == self.infer_state.builtins_module: and self.parent_context == self.infer_state.builtins_module:
return [] return []
return [LazyKnownValues( return [LazyKnownValues(
self.infer_state.builtins_module.py__getattribute__('object') self.infer_state.builtins_module.py__getattribute__('object')
jedi/inference/value/module.py
+6 -6
View File
@@ -20,20 +20,20 @@ class _ModuleAttributeName(AbstractNameDefinition):
api_type = u'instance' api_type = u'instance'
def __init__(self, parent_module, string_name, string_value=None): def __init__(self, parent_module, string_name, string_value=None):
self.parent_value = parent_module self.parent_context = parent_module
self.string_name = string_name self.string_name = string_name
self._string_value = string_value self._string_value = string_value
def infer(self): def infer(self):
if self._string_value is not None: if self._string_value is not None:
s = self._string_value s = self._string_value
if self.parent_value.infer_state.environment.version_info.major == 2 \ if self.parent_context.infer_state.environment.version_info.major == 2 \
and not isinstance(s, bytes): and not isinstance(s, bytes):
s = s.encode('utf-8') s = s.encode('utf-8')
return ValueSet([ return ValueSet([
create_simple_object(self.parent_value.infer_state, s) create_simple_object(self.parent_context.infer_state, s)
]) ])
return compiled.get_string_value_set(self.parent_value.infer_state) return compiled.get_string_value_set(self.parent_context.infer_state)
class ModuleName(ValueNameMixin, AbstractNameDefinition): class ModuleName(ValueNameMixin, AbstractNameDefinition):
@@ -189,12 +189,12 @@ class ModuleMixin(SubModuleDictMixin):
class ModuleValue(ModuleMixin, TreeValue): class ModuleValue(ModuleMixin, TreeValue):
api_type = u'module' api_type = u'module'
parent_value = None parent_context = None
def __init__(self, infer_state, module_node, file_io, string_names, code_lines, is_package=False): def __init__(self, infer_state, module_node, file_io, string_names, code_lines, is_package=False):
super(ModuleValue, self).__init__( super(ModuleValue, self).__init__(
infer_state, infer_state,
parent_value=None, parent_context=None,
tree_node=module_node tree_node=module_node
) )
self.file_io = file_io self.file_io = file_io
jedi/inference/value/namespace.py
+2 -2
View File
@@ -23,10 +23,10 @@ class ImplicitNamespaceValue(Value, SubModuleDictMixin):
# folder foobar it will be available as an object: # folder foobar it will be available as an object:
# <module 'foobar' (namespace)>. # <module 'foobar' (namespace)>.
api_type = u'module' api_type = u'module'
parent_value = None parent_context = None
def __init__(self, infer_state, fullname, paths): def __init__(self, infer_state, fullname, paths):
super(ImplicitNamespaceValue, self).__init__(infer_state, parent_value=None) super(ImplicitNamespaceValue, self).__init__(infer_state, parent_context=None)
self.infer_state = infer_state self.infer_state = infer_state
self._fullname = fullname self._fullname = fullname
self._paths = paths self._paths = paths
jedi/plugins/stdlib.py
+9 -9
View File
@@ -114,10 +114,10 @@ def execute(callback):
except AttributeError: except AttributeError:
pass pass
else: else:
if value.parent_value == value.infer_state.builtins_module: if value.parent_context == value.infer_state.builtins_module:
module_name = 'builtins' module_name = 'builtins'
elif value.parent_value is not None and value.parent_value.is_module(): elif value.parent_context is not None and value.parent_context.is_module():
module_name = value.parent_value.py__name__() module_name = value.parent_context.py__name__()
else: else:
return call() return call()
@@ -472,14 +472,14 @@ def collections_namedtuple(obj, arguments, callback):
# Parse source code # Parse source code
module = infer_state.grammar.parse(code) module = infer_state.grammar.parse(code)
generated_class = next(module.iter_classdefs()) generated_class = next(module.iter_classdefs())
parent_value = ModuleValue( parent_context = ModuleValue(
infer_state, module, infer_state, module,
file_io=None, file_io=None,
string_names=None, string_names=None,
code_lines=parso.split_lines(code, keepends=True), code_lines=parso.split_lines(code, keepends=True),
) )
return ValueSet([ClassValue(infer_state, parent_value, generated_class)]) return ValueSet([ClassValue(infer_state, parent_context, generated_class)])
class PartialObject(object): class PartialObject(object):
@@ -597,7 +597,7 @@ class DataclassWrapper(ValueWrapper, ClassMixin):
else: else:
default = annassign.children[3] default = annassign.children[3]
param_names.append(DataclassParamName( param_names.append(DataclassParamName(
parent_value=cls.parent_value, parent_context=cls.parent_context,
tree_name=name.tree_name, tree_name=name.tree_name,
annotation_node=annassign.children[1], annotation_node=annassign.children[1],
default_node=default, default_node=default,
@@ -615,8 +615,8 @@ class DataclassSignature(AbstractSignature):
class DataclassParamName(BaseTreeParamName): class DataclassParamName(BaseTreeParamName):
def __init__(self, parent_value, tree_name, annotation_node, default_node): def __init__(self, parent_context, tree_name, annotation_node, default_node):
super(DataclassParamName, self).__init__(parent_value, tree_name) super(DataclassParamName, self).__init__(parent_context, tree_name)
self.annotation_node = annotation_node self.annotation_node = annotation_node
self.default_node = default_node self.default_node = default_node
@@ -627,7 +627,7 @@ class DataclassParamName(BaseTreeParamName):
if self.annotation_node is None: if self.annotation_node is None:
return NO_VALUES return NO_VALUES
else: else:
return self.parent_value.infer_node(self.annotation_node) return self.parent_context.infer_node(self.annotation_node)
class ItemGetterCallable(ValueWrapper): class ItemGetterCallable(ValueWrapper):
test/test_inference/test_compiled.py
+3 -3
View File
@@ -122,7 +122,7 @@ def _return_int():
('ret_int', '_return_int', 'test.test_inference.test_compiled'), ('ret_int', '_return_int', 'test.test_inference.test_compiled'),
] ]
) )
def test_parent_value(same_process_infer_state, attribute, expected_name, expected_parent): def test_parent_context(same_process_infer_state, attribute, expected_name, expected_parent):
import decimal import decimal
class C: class C:
@@ -140,11 +140,11 @@ def test_parent_value(same_process_infer_state, attribute, expected_name, expect
) )
x, = o.py__getattribute__(attribute) x, = o.py__getattribute__(attribute)
assert x.py__name__() == expected_name assert x.py__name__() == expected_name
module_name = x.parent_value.py__name__() module_name = x.parent_context.py__name__()
if module_name == '__builtin__': if module_name == '__builtin__':
module_name = 'builtins' # Python 2 module_name = 'builtins' # Python 2
assert module_name == expected_parent assert module_name == expected_parent
assert x.parent_value.parent_value is None assert x.parent_context.parent_context is None
@pytest.mark.skipif(sys.version_info[0] == 2, reason="Ignore Python 2, because EOL") @pytest.mark.skipif(sys.version_info[0] == 2, reason="Ignore Python 2, because EOL")
test/test_inference/test_imports.py
+2 -2
View File
@@ -156,8 +156,8 @@ def test_not_importable_file(Script):
def test_import_unique(Script): def test_import_unique(Script):
src = "import os; os.path" src = "import os; os.path"
defs = Script(src, path='example.py').goto_definitions() defs = Script(src, path='example.py').goto_definitions()
parent_values = [d._name._value for d in defs] parent_contexts = [d._name._value for d in defs]
assert len(parent_values) == len(set(parent_values)) assert len(parent_contexts) == len(set(parent_contexts))
def test_cache_works_with_sys_path_param(Script, tmpdir): def test_cache_works_with_sys_path_param(Script, tmpdir):
test/test_settings.py
+1 -1
View File
@@ -15,7 +15,7 @@ def test_base_auto_import_modules(auto_import_json, Script):
loads, = Script('import json; json.loads').goto_definitions() loads, = Script('import json; json.loads').goto_definitions()
assert isinstance(loads._name, ValueName) assert isinstance(loads._name, ValueName)
value, = loads._name.infer() value, = loads._name.infer()
assert isinstance(value.parent_value, StubModuleValue) assert isinstance(value.parent_context, StubModuleValue)
def test_auto_import_modules_imports(auto_import_json, Script): def test_auto_import_modules_imports(auto_import_json, Script):