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

infer_state -> inference_state

Browse Source
This commit is contained in:
Dave Halter
2019-08-16 11:44:30 +02:00
parent fffb39227e
commit 03920502c4
60 changed files with 727 additions and 727 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
jedi/api/__init__.py
View File

@@ -111,11 +111,11 @@ class Script(object):
# TODO deprecate and remove sys_path from the Script API.
if sys_path is not None:
project._sys_path = sys_path
self._infer_state = InferenceState(
self._inference_state = InferenceState(
project, environment=environment, script_path=self.path
)
debug.speed('init')
self._module_node, source = self._infer_state.parse_and_get_code(
self._module_node, source = self._inference_state.parse_and_get_code(
code=source,
path=self.path,
encoding=encoding,
@@ -156,7 +156,7 @@ class Script(object):
is_package = False
if self.path is not None:
import_names, is_p = transform_path_to_dotted(
self._infer_state.get_sys_path(add_parent_paths=False),
self._inference_state.get_sys_path(add_parent_paths=False),
self.path
)
if import_names is not None:
@@ -170,7 +170,7 @@ class Script(object):
if self.path is not None and self.path.endswith('.pyi'):
# We are in a stub file. Try to load the stub properly.
stub_module = load_proper_stub_module(
self._infer_state,
self._inference_state,
file_io,
names,
self._module_node
@@ -182,21 +182,21 @@ class Script(object):
names = ('__main__',)
module = ModuleValue(
self._infer_state, self._module_node, file_io,
self._inference_state, self._module_node, file_io,
string_names=names,
code_lines=self._code_lines,
is_package=is_package,
)
if names[0] not in ('builtins', '__builtin__', 'typing'):
# These modules are essential for Jedi, so don't overwrite them.
self._infer_state.module_cache.add(names, ValueSet([module]))
self._inference_state.module_cache.add(names, ValueSet([module]))
return module
def __repr__(self):
return '<%s: %s %r>' % (
self.__class__.__name__,
repr(self._orig_path),
self._infer_state.environment,
self._inference_state.environment,
)
def completions(self):
@@ -209,7 +209,7 @@ class Script(object):
"""
with debug.increase_indent_cm('completions'):
completion = Completion(
self._infer_state, self._get_module(), self._code_lines,
self._inference_state, self._get_module(), self._code_lines,
self._pos, self.call_signatures
)
return completion.completions()
@@ -239,16 +239,16 @@ class Script(object):
if leaf is None:
return []
value = self._infer_state.create_value(self._get_module(), leaf)
value = self._inference_state.create_value(self._get_module(), leaf)
values = helpers.infer_goto_definition(self._infer_state, value, leaf)
values = helpers.infer_goto_definition(self._inference_state, value, leaf)
values = convert_values(
values,
only_stubs=only_stubs,
prefer_stubs=prefer_stubs,
)
defs = [classes.Definition(self._infer_state, c.name) for c in values]
defs = [classes.Definition(self._inference_state, c.name) for c in values]
# The additional set here allows the definitions to become unique in an
# API sense. In the internals we want to separate more things than in
# the API.
@@ -299,8 +299,8 @@ class Script(object):
# Without a name we really just want to jump to the result e.g.
# executed by `foo()`, if we the cursor is after `)`.
return self.goto_definitions(only_stubs=only_stubs, prefer_stubs=prefer_stubs)
value = self._infer_state.create_value(self._get_module(), tree_name)
names = list(self._infer_state.goto(value, tree_name))
value = self._inference_state.create_value(self._get_module(), tree_name)
names = list(self._inference_state.goto(value, tree_name))
if follow_imports:
names = filter_follow_imports(names, lambda name: name.is_import())
@@ -310,7 +310,7 @@ class Script(object):
prefer_stubs=prefer_stubs,
)
defs = [classes.Definition(self._infer_state, d) for d in set(names)]
defs = [classes.Definition(self._inference_state, d) for d in set(names)]
return helpers.sorted_definitions(defs)
def usages(self, additional_module_paths=(), **kwargs):
@@ -342,7 +342,7 @@ class Script(object):
names = usages.usages(self._get_module(), tree_name)
definitions = [classes.Definition(self._infer_state, n) for n in names]
definitions = [classes.Definition(self._inference_state, n) for n in names]
if not include_builtins:
definitions = [d for d in definitions if not d.in_builtin_module()]
return helpers.sorted_definitions(definitions)
@@ -368,12 +368,12 @@ class Script(object):
if call_details is None:
return []
value = self._infer_state.create_value(
value = self._inference_state.create_value(
self._get_module(),
call_details.bracket_leaf
)
definitions = helpers.cache_call_signatures(
self._infer_state,
self._inference_state,
value,
call_details.bracket_leaf,
self._code_lines,
@@ -383,19 +383,19 @@ class Script(object):
# TODO here we use stubs instead of the actual values. We should use
# the signatures from stubs, but the actual values, probably?!
return [classes.CallSignature(self._infer_state, signature, call_details)
return [classes.CallSignature(self._inference_state, signature, call_details)
for signature in definitions.get_signatures()]
def _analysis(self):
self._infer_state.is_analysis = True
self._infer_state.analysis_modules = [self._module_node]
self._inference_state.is_analysis = True
self._inference_state.analysis_modules = [self._module_node]
module = self._get_module()
try:
for node in get_executable_nodes(self._module_node):
value = module.create_value(node)
if node.type in ('funcdef', 'classdef'):
# Resolve the decorators.
tree_name_to_values(self._infer_state, value, node.children[1])
tree_name_to_values(self._inference_state, value, node.children[1])
elif isinstance(node, tree.Import):
import_names = set(node.get_defined_names())
if node.is_nested():
@@ -409,16 +409,16 @@ class Script(object):
unpack_tuple_to_dict(value, types, testlist)
else:
if node.type == 'name':
defs = self._infer_state.goto_definitions(value, node)
defs = self._inference_state.goto_definitions(value, node)
else:
defs = infer_call_of_leaf(value, node)
try_iter_content(defs)
self._infer_state.reset_recursion_limitations()
self._inference_state.reset_recursion_limitations()
ana = [a for a in self._infer_state.analysis if self.path == a.path]
ana = [a for a in self._inference_state.analysis if self.path == a.path]
return sorted(set(ana), key=lambda x: x.line)
finally:
self._infer_state.is_analysis = False
self._inference_state.is_analysis = False
class Interpreter(Script):
@@ -467,11 +467,11 @@ class Interpreter(Script):
super(Interpreter, self).__init__(source, environment=environment,
_project=Project(os.getcwd()), **kwds)
self.namespaces = namespaces
self._infer_state.allow_descriptor_getattr = self._allow_descriptor_getattr_default
self._inference_state.allow_descriptor_getattr = self._allow_descriptor_getattr_default
def _get_module(self):
return interpreter.MixedModuleValue(
self._infer_state,
self._inference_state,
self._module_node,
self.namespaces,
file_io=KnownContentFileIO(self.path, self._code),
@@ -514,7 +514,7 @@ def names(source=None, path=None, encoding='utf-8', all_scopes=False,
module_value = script._get_module()
defs = [
classes.Definition(
script._infer_state,
script._inference_state,
create_name(name)
) for name in get_module_names(script._module_node, all_scopes)
]

44
jedi/api/classes.py
View File

@@ -25,7 +25,7 @@ def _sort_names_by_start_pos(names):
return sorted(names, key=lambda s: s.start_pos or (0, 0))
def defined_names(infer_state, value):
def defined_names(inference_state, value):
"""
List sub-definitions (e.g., methods in class).
@@ -34,11 +34,11 @@ def defined_names(infer_state, value):
"""
filter = next(value.get_filters(search_global=True))
names = [name for name in filter.values()]
return [Definition(infer_state, n) for n in _sort_names_by_start_pos(names)]
return [Definition(inference_state, n) for n in _sort_names_by_start_pos(names)]
def _values_to_definitions(values):
return [Definition(c.infer_state, c.name) for c in values]
return [Definition(c.inference_state, c.name) for c in values]
class BaseDefinition(object):
@@ -62,8 +62,8 @@ class BaseDefinition(object):
'argparse._ActionsContainer': 'argparse.ArgumentParser',
}.items())
def __init__(self, infer_state, name):
self._infer_state = infer_state
def __init__(self, inference_state, name):
self._inference_state = inference_state
self._name = name
"""
An instance of :class:`parso.python.tree.Name` subclass.
@@ -306,7 +306,7 @@ class BaseDefinition(object):
only_stubs=only_stubs,
prefer_stubs=prefer_stubs,
)
return [self if n == self._name else Definition(self._infer_state, n)
return [self if n == self._name else Definition(self._inference_state, n)
for n in names]
def infer(self, **kwargs): # Python 2...
@@ -329,7 +329,7 @@ class BaseDefinition(object):
prefer_stubs=prefer_stubs,
)
resulting_names = [c.name for c in values]
return [self if n == self._name else Definition(self._infer_state, n)
return [self if n == self._name else Definition(self._inference_state, n)
for n in resulting_names]
@property
@@ -346,7 +346,7 @@ class BaseDefinition(object):
for value in self._name.infer():
for signature in value.get_signatures():
return [
Definition(self._infer_state, n)
Definition(self._inference_state, n)
for n in signature.get_param_names(resolve_stars=True)
]
@@ -366,7 +366,7 @@ class BaseDefinition(object):
if isinstance(value, FunctionExecutionValue):
value = value.function_value
return Definition(self._infer_state, value.name)
return Definition(self._inference_state, value.name)
def __repr__(self):
return "<%s %sname=%r, description=%r>" % (
@@ -396,7 +396,7 @@ class BaseDefinition(object):
return ''.join(lines[start_index:index + after + 1])
def get_signatures(self):
return [Signature(self._infer_state, s) for s in self._name.infer().get_signatures()]
return [Signature(self._inference_state, s) for s in self._name.infer().get_signatures()]
def execute(self):
return _values_to_definitions(self._name.infer().execute_with_values())
@@ -407,8 +407,8 @@ class Completion(BaseDefinition):
`Completion` objects are returned from :meth:`api.Script.completions`. They
provide additional information about a completion.
"""
def __init__(self, infer_state, name, stack, like_name_length):
super(Completion, self).__init__(infer_state, name)
def __init__(self, inference_state, name, stack, like_name_length):
super(Completion, self).__init__(inference_state, name)
self._like_name_length = like_name_length
self._stack = stack
@@ -512,8 +512,8 @@ class Definition(BaseDefinition):
*Definition* objects are returned from :meth:`api.Script.goto_assignments`
or :meth:`api.Script.goto_definitions`.
"""
def __init__(self, infer_state, definition):
super(Definition, self).__init__(infer_state, definition)
def __init__(self, inference_state, definition):
super(Definition, self).__init__(inference_state, definition)
@property
def description(self):
@@ -588,7 +588,7 @@ class Definition(BaseDefinition):
"""
defs = self._name.infer()
return sorted(
unite(defined_names(self._infer_state, d) for d in defs),
unite(defined_names(self._inference_state, d) for d in defs),
key=lambda s: s._name.start_pos or (0, 0)
)
@@ -606,13 +606,13 @@ class Definition(BaseDefinition):
return self._name.start_pos == other._name.start_pos \
and self.module_path == other.module_path \
and self.name == other.name \
and self._infer_state == other._infer_state
and self._inference_state == other._inference_state
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return hash((self._name.start_pos, self.module_path, self.name, self._infer_state))
return hash((self._name.start_pos, self.module_path, self.name, self._inference_state))
class Signature(Definition):
@@ -621,8 +621,8 @@ class Signature(Definition):
It knows what functions you are currently in. e.g. `isinstance(` would
return the `isinstance` function. without `(` it would return nothing.
"""
def __init__(self, infer_state, signature):
super(Signature, self).__init__(infer_state, signature.name)
def __init__(self, inference_state, signature):
super(Signature, self).__init__(inference_state, signature.name)
self._signature = signature
@property
@@ -630,7 +630,7 @@ class Signature(Definition):
"""
:return list of ParamDefinition:
"""
return [ParamDefinition(self._infer_state, n)
return [ParamDefinition(self._inference_state, n)
for n in self._signature.get_param_names(resolve_stars=True)]
def to_string(self):
@@ -644,8 +644,8 @@ class CallSignature(Signature):
return the `isinstance` function with its params. Without `(` it would
return nothing.
"""
def __init__(self, infer_state, signature, call_details):
super(CallSignature, self).__init__(infer_state, signature)
def __init__(self, inference_state, signature, call_details):
super(CallSignature, self).__init__(inference_state, signature)
self._call_details = call_details
self._signature = signature

24
jedi/api/completion.py
View File

@@ -28,7 +28,7 @@ def get_call_signature_param_names(call_signatures):
yield p._name
def filter_names(infer_state, completion_names, stack, like_name):
def filter_names(inference_state, completion_names, stack, like_name):
comp_dct = {}
if settings.case_insensitive_completion:
like_name = like_name.lower()
@@ -39,7 +39,7 @@ def filter_names(infer_state, completion_names, stack, like_name):
if string.startswith(like_name):
new = classes.Completion(
infer_state,
inference_state,
name,
stack,
len(like_name)
@@ -85,8 +85,8 @@ def get_flow_scope_node(module_node, position):
class Completion:
def __init__(self, infer_state, module, code_lines, position, call_signatures_callback):
self._infer_state = infer_state
def __init__(self, inference_state, module, code_lines, position, call_signatures_callback):
self._inference_state = inference_state
self._module_value = module
self._module_node = module.tree_node
self._code_lines = code_lines
@@ -104,7 +104,7 @@ class Completion:
string, start_leaf = _extract_string_while_in_string(leaf, self._position)
if string is not None:
completions = list(file_name_completions(
self._infer_state, self._module_value, start_leaf, string,
self._inference_state, self._module_value, start_leaf, string,
self._like_name, self._call_signatures_callback,
self._code_lines, self._original_position
))
@@ -113,7 +113,7 @@ class Completion:
completion_names = self._get_value_completions(leaf)
completions = filter_names(self._infer_state, completion_names,
completions = filter_names(self._inference_state, completion_names,
self.stack, self._like_name)
return sorted(completions, key=lambda x: (x.name.startswith('__'),
@@ -135,7 +135,7 @@ class Completion:
- In params (also lambda): no completion before =
"""
grammar = self._infer_state.grammar
grammar = self._inference_state.grammar
self.stack = stack = None
try:
@@ -234,14 +234,14 @@ class Completion:
def _get_keyword_completion_names(self, allowed_transitions):
for k in allowed_transitions:
if isinstance(k, str) and k.isalpha():
yield keywords.KeywordName(self._infer_state, k)
yield keywords.KeywordName(self._inference_state, k)
def _global_completions(self):
value = get_user_scope(self._module_value, self._position)
debug.dbg('global completion scope: %s', value)
flow_scope_node = get_flow_scope_node(self._module_node, self._position)
filters = get_global_filters(
self._infer_state,
self._inference_state,
value,
self._position,
origin_scope=flow_scope_node
@@ -253,7 +253,7 @@ class Completion:
def _trailer_completions(self, previous_leaf):
user_value = get_user_scope(self._module_value, self._position)
inferred_value = self._infer_state.create_value(
inferred_value = self._inference_state.create_value(
self._module_value, previous_leaf
)
values = infer_call_of_leaf(inferred_value, previous_leaf)
@@ -276,8 +276,8 @@ class Completion:
def _get_importer_names(self, names, level=0, only_modules=True):
names = [n.value for n in names]
i = imports.Importer(self._infer_state, names, self._module_value, level)
return i.completion_names(self._infer_state, only_modules=only_modules)
i = imports.Importer(self._inference_state, names, self._module_value, level)
return i.completion_names(self._inference_state, only_modules=only_modules)
def _get_class_value_completions(self, is_function=True):
"""

8
jedi/api/environment.py
View File

@@ -109,8 +109,8 @@ class Environment(_BaseEnvironment):
version = '.'.join(str(i) for i in self.version_info)
return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path)
def get_infer_state_subprocess(self, infer_state):
return InferenceStateSubprocess(infer_state, self._get_subprocess())
def get_inference_state_subprocess(self, inference_state):
return InferenceStateSubprocess(inference_state, self._get_subprocess())
@memoize_method
def get_sys_path(self):
@@ -140,8 +140,8 @@ class SameEnvironment(_SameEnvironmentMixin, Environment):
class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment):
def get_infer_state_subprocess(self, infer_state):
return InferenceStateSameProcess(infer_state)
def get_inference_state_subprocess(self, inference_state):
return InferenceStateSameProcess(inference_state)
def get_sys_path(self):
return sys.path

8
jedi/api/file_name.py
View File

@@ -7,7 +7,7 @@ from jedi.inference.helpers import get_str_or_none
from jedi.parser_utils import get_string_quote
def file_name_completions(infer_state, module_value, start_leaf, string,
def file_name_completions(inference_state, module_value, start_leaf, string,
like_name, call_signatures_callback, code_lines, position):
# First we want to find out what can actually be changed as a name.
like_name_length = len(os.path.basename(string) + like_name)
@@ -30,7 +30,7 @@ def file_name_completions(infer_state, module_value, start_leaf, string,
is_in_os_path_join = False
else:
string = to_be_added + string
base_path = os.path.join(infer_state.project._path, string)
base_path = os.path.join(inference_state.project._path, string)
try:
listed = os.listdir(base_path)
except FileNotFoundError:
@@ -53,8 +53,8 @@ def file_name_completions(infer_state, module_value, start_leaf, string,
name += os.path.sep
yield classes.Completion(
infer_state,
FileName(infer_state, name[len(must_start_with) - like_name_length:]),
inference_state,
FileName(inference_state, name[len(must_start_with) - like_name_length:]),
stack=None,
like_name_length=like_name_length
)

10
jedi/api/helpers.py
View File

@@ -136,11 +136,11 @@ def get_stack_at_position(grammar, code_lines, leaf, pos):
)
def infer_goto_definition(infer_state, value, leaf):
def infer_goto_definition(inference_state, value, leaf):
if leaf.type == 'name':
# In case of a name we can just use goto_definition which does all the
# magic itself.
return infer_state.goto_definitions(value, leaf)
return inference_state.goto_definitions(value, leaf)
parent = leaf.parent
definitions = NO_VALUES
@@ -154,7 +154,7 @@ def infer_goto_definition(infer_state, value, leaf):
# e.g. `"foo"` or `1.0`
return infer_atom(value, leaf)
elif leaf.type in ('fstring_string', 'fstring_start', 'fstring_end'):
return get_string_value_set(infer_state)
return get_string_value_set(inference_state)
return definitions
@@ -376,7 +376,7 @@ def get_call_signature_details(module, position):
@call_signature_time_cache("call_signatures_validity")
def cache_call_signatures(infer_state, value, bracket_leaf, code_lines, user_pos):
def cache_call_signatures(inference_state, value, bracket_leaf, code_lines, user_pos):
"""This function calculates the cache key."""
line_index = user_pos[0] - 1
@@ -391,7 +391,7 @@ def cache_call_signatures(infer_state, value, bracket_leaf, code_lines, user_pos
else:
yield (module_path, before_bracket, bracket_leaf.start_pos)
yield infer_goto_definition(
infer_state,
inference_state,
value,
bracket_leaf.get_previous_leaf(),
)

10
jedi/api/interpreter.py
View File

@@ -9,9 +9,9 @@ from jedi.inference.compiled.access import create_access_path
from jedi.inference.base_value import ValueWrapper
def _create(infer_state, obj):
def _create(inference_state, obj):
return compiled.create_from_access_path(
infer_state, create_access_path(infer_state, obj)
inference_state, create_access_path(inference_state, obj)
)
@@ -23,9 +23,9 @@ class NamespaceObject(object):
class MixedModuleValue(ValueWrapper):
type = 'mixed_module'
def __init__(self, infer_state, tree_module, namespaces, file_io, code_lines):
def __init__(self, inference_state, tree_module, namespaces, file_io, code_lines):
module_value = ModuleValue(
infer_state, tree_module,
inference_state, tree_module,
file_io=file_io,
string_names=('__main__',),
code_lines=code_lines
@@ -38,7 +38,7 @@ class MixedModuleValue(ValueWrapper):
yield filter
for namespace_obj in self._namespace_objects:
compiled_object = _create(self.infer_state, namespace_obj)
compiled_object = _create(self.inference_state, namespace_obj)
mixed_object = mixed.MixedObject(
compiled_object=compiled_object,
tree_value=self._wrapped_value

12
jedi/api/keywords.py
View File

@@ -15,24 +15,24 @@ except ImportError:
pydoc_topics = None
def get_operator(infer_state, string, pos):
return Keyword(infer_state, string, pos)
def get_operator(inference_state, string, pos):
return Keyword(inference_state, string, pos)
class KeywordName(AbstractArbitraryName):
api_type = u'keyword'
def infer(self):
return [Keyword(self.infer_state, self.string_name, (0, 0))]
return [Keyword(self.inference_state, self.string_name, (0, 0))]
class Keyword(object):
api_type = u'keyword'
def __init__(self, infer_state, name, pos):
self.name = KeywordName(infer_state, name)
def __init__(self, inference_state, name, pos):
self.name = KeywordName(inference_state, name)
self.start_pos = pos
self.parent = infer_state.builtins_module
self.parent = inference_state.builtins_module
@property
def names(self):

18
jedi/api/project.py
View File

@@ -7,7 +7,7 @@ from jedi.api.environment import SameEnvironment, \
from jedi.api.exceptions import WrongVersion
from jedi._compatibility import force_unicode
from jedi.inference.sys_path import discover_buildout_paths
from jedi.inference.cache import infer_state_as_method_param_cache
from jedi.inference.cache import inference_state_as_method_param_cache
from jedi.common.utils import traverse_parents
_CONFIG_FOLDER = '.jedi'
@@ -77,8 +77,8 @@ class Project(object):
py2_comp(path, **kwargs)
@infer_state_as_method_param_cache()
def _get_base_sys_path(self, infer_state, environment=None):
@inference_state_as_method_param_cache()
def _get_base_sys_path(self, inference_state, environment=None):
if self._sys_path is not None:
return self._sys_path
@@ -93,8 +93,8 @@ class Project(object):
pass
return sys_path
@infer_state_as_method_param_cache()
def _get_sys_path(self, infer_state, environment=None, add_parent_paths=True):
@inference_state_as_method_param_cache()
def _get_sys_path(self, inference_state, environment=None, add_parent_paths=True):
"""
Keep this method private for all users of jedi. However internally this
one is used like a public method.
@@ -102,15 +102,15 @@ class Project(object):
suffixed = []
prefixed = []
sys_path = list(self._get_base_sys_path(infer_state, environment))
sys_path = list(self._get_base_sys_path(inference_state, environment))
if self._smart_sys_path:
prefixed.append(self._path)
if infer_state.script_path is not None:
suffixed += discover_buildout_paths(infer_state, infer_state.script_path)
if inference_state.script_path is not None:
suffixed += discover_buildout_paths(inference_state, inference_state.script_path)
if add_parent_paths:
traversed = list(traverse_parents(infer_state.script_path))
traversed = list(traverse_parents(inference_state.script_path))
# AFAIK some libraries have imports like `foo.foo.bar`, which
# leads to the conclusion to by default prefer longer paths

4
jedi/common/value.py
View File

@@ -1,6 +1,6 @@
class BaseValue(object):
def __init__(self, infer_state, parent_context=None):
self.infer_state = infer_state
def __init__(self, inference_state, parent_context=None):
self.inference_state = inference_state
self.parent_context = parent_context
def get_root_value(self):

12
jedi/inference/__init__.py
View File

@@ -15,7 +15,7 @@ Type inference of Python code in |jedi| is based on three assumptions:
The actual algorithm is based on a principle I call lazy type inference. That
said, the typical entry point for static analysis is calling
``infer_expr_stmt``. There's separate logic for autocompletion in the API, the
infer_state is all about inferring an expression.
inference_state is all about inferring an expression.
TODO this paragraph is not what jedi does anymore, it's similar, but not the
same.
@@ -72,7 +72,7 @@ from jedi import parser_utils
from jedi.inference.utils import unite
from jedi.inference import imports
from jedi.inference import recursion
from jedi.inference.cache import infer_state_function_cache
from jedi.inference.cache import inference_state_function_cache
from jedi.inference import helpers
from jedi.inference.names import TreeNameDefinition, ParamName
from jedi.inference.base_value import ValueualizedName, ValueualizedNode, \
@@ -91,7 +91,7 @@ class InferenceState(object):
environment = project.get_environment()
self.environment = environment
self.script_path = script_path
self.compiled_subprocess = environment.get_infer_state_subprocess(self)
self.compiled_subprocess = environment.get_inference_state_subprocess(self)
self.grammar = environment.get_grammar()
self.latest_grammar = parso.load_grammar(version='3.7')
@@ -128,7 +128,7 @@ class InferenceState(object):
return value_set
@property
@infer_state_function_cache()
@inference_state_function_cache()
def builtins_module(self):
module_name = u'builtins'
if self.environment.version_info.major == 2:
@@ -137,7 +137,7 @@ class InferenceState(object):
return builtins_module
@property
@infer_state_function_cache()
@inference_state_function_cache()
def typing_module(self):
typing_module, = self.import_module((u'typing',))
return typing_module
@@ -233,7 +233,7 @@ class InferenceState(object):
return infer_node(value, element)
return self._infer_element_cached(value, element)
@infer_state_function_cache(default=NO_VALUES)
@inference_state_function_cache(default=NO_VALUES)
def _infer_element_cached(self, value, element):
return infer_node(value, element)

6
jedi/inference/analysis.py
View File

@@ -87,7 +87,7 @@ def add(node_value, error_name, node, message=None, typ=Error, payload=None):
module_path = module_value.py__file__()
issue_instance = typ(error_name, module_path, node.start_pos, message)
debug.warning(str(issue_instance), format=False)
node_value.infer_state.analysis.append(issue_instance)
node_value.inference_state.analysis.append(issue_instance)
return issue_instance
@@ -149,7 +149,7 @@ def _check_for_exception_catch(node_value, jedi_name, exception, payload=None):
for python_cls in exception.mro():
if cls.py__name__() == python_cls.__name__ \
and cls.parent_context == cls.infer_state.builtins_module:
and cls.parent_context == cls.inference_state.builtins_module:
return True
return False
@@ -192,7 +192,7 @@ def _check_for_exception_catch(node_value, jedi_name, exception, payload=None):
arglist = trailer.children[1]
assert arglist.type == 'arglist'
from jedi.inference.arguments import TreeArguments
args = list(TreeArguments(node_value.infer_state, node_value, arglist).unpack())
args = list(TreeArguments(node_value.inference_state, node_value, arglist).unpack())
# Arguments should be very simple
assert len(args) == 2

18
jedi/inference/arguments.py
View File

@@ -11,7 +11,7 @@ from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \
from jedi.inference.names import ParamName, TreeNameDefinition
from jedi.inference.base_value import NO_VALUES, ValueSet, ValueualizedNode
from jedi.inference.value import iterable
from jedi.inference.cache import infer_state_as_method_param_cache
from jedi.inference.cache import inference_state_as_method_param_cache
from jedi.inference.param import get_executed_params_and_issues, ExecutedParam
@@ -59,7 +59,7 @@ def repack_with_argument_clinic(string, keep_arguments_param=False, keep_callbac
kwargs.pop('callback', None)
try:
args += tuple(_iterate_argument_clinic(
value.infer_state,
value.inference_state,
arguments,
clinic_args
))
@@ -72,7 +72,7 @@ def repack_with_argument_clinic(string, keep_arguments_param=False, keep_callbac
return decorator
def _iterate_argument_clinic(infer_state, arguments, parameters):
def _iterate_argument_clinic(inference_state, arguments, parameters):
"""Uses a list with argument clinic information (see PEP 436)."""
iterator = PushBackIterator(arguments.unpack())
for i, (name, optional, allow_kwargs, stars) in enumerate(parameters):
@@ -84,7 +84,7 @@ def _iterate_argument_clinic(infer_state, arguments, parameters):
break
lazy_values.append(argument)
yield ValueSet([iterable.FakeSequence(infer_state, u'tuple', lazy_values)])
yield ValueSet([iterable.FakeSequence(inference_state, u'tuple', lazy_values)])
lazy_values
continue
elif stars == 2:
@@ -161,7 +161,7 @@ class AnonymousArguments(AbstractArguments):
def get_executed_params_and_issues(self, execution_value):
from jedi.inference.dynamic import search_params
return search_params(
execution_value.infer_state,
execution_value.inference_state,
execution_value,
execution_value.tree_node
), []
@@ -198,17 +198,17 @@ def unpack_arglist(arglist):
class TreeArguments(AbstractArguments):
def __init__(self, infer_state, value, argument_node, trailer=None):
def __init__(self, inference_state, value, argument_node, trailer=None):
"""
:param argument_node: May be an argument_node or a list of nodes.
"""
self.argument_node = argument_node
self.value = value
self._infer_state = infer_state
self._inference_state = inference_state
self.trailer = trailer # Can be None, e.g. in a class definition.
@classmethod
@infer_state_as_method_param_cache()
@inference_state_as_method_param_cache()
def create_cached(cls, *args, **kwargs):
return cls(*args, **kwargs)
@@ -241,7 +241,7 @@ class TreeArguments(AbstractArguments):
if sync_comp_for.type == 'comp_for':
sync_comp_for = sync_comp_for.children[1]
comp = iterable.GeneratorComprehension(
self._infer_state,
self._inference_state,
defining_value=self.value,
sync_comp_for_node=sync_comp_for,
entry_node=el.children[0],

24
jedi/inference/base_value.py
View File

@@ -16,7 +16,7 @@ from jedi.parser_utils import clean_scope_docstring
from jedi.common import BaseValueSet, BaseValue
from jedi.inference.helpers import SimpleGetItemNotFound
from jedi.inference.utils import safe_property
from jedi.inference.cache import infer_state_as_method_param_cache
from jedi.inference.cache import inference_state_as_method_param_cache
from jedi.cache import memoize_method
_sentinel = object()
@@ -31,17 +31,17 @@ class HelperValueMixin(object):
value = value.parent_context
@classmethod
@infer_state_as_method_param_cache()
@inference_state_as_method_param_cache()
def create_cached(cls, *args, **kwargs):
return cls(*args, **kwargs)
def execute(self, arguments):
return self.infer_state.execute(self, arguments=arguments)
return self.inference_state.execute(self, arguments=arguments)
def execute_with_values(self, *value_list):
from jedi.inference.arguments import ValuesArguments
arguments = ValuesArguments([ValueSet([value]) for value in value_list])
return self.infer_state.execute(self, arguments)
return self.inference_state.execute(self, arguments)
def execute_annotation(self):
return self.execute_with_values()
@@ -64,7 +64,7 @@ class HelperValueMixin(object):
if name_value is None:
name_value = self
from jedi.inference import finder
f = finder.NameFinder(self.infer_state, self, name_value, name_or_str,
f = finder.NameFinder(self.inference_state, self, name_value, name_or_str,
position, analysis_errors=analysis_errors)
if search_global:
filters = f.get_global_filters()
@@ -81,10 +81,10 @@ class HelperValueMixin(object):
return await_value_set.execute_with_values()
def infer_node(self, node):
return self.infer_state.infer_element(self, node)
return self.inference_state.infer_element(self, node)
def create_value(self, node, node_is_value=False, node_is_object=False):
return self.infer_state.create_value(self, node, node_is_value, node_is_object)
return self.inference_state.create_value(self, node, node_is_value, node_is_object)
def iterate(self, valueualized_node=None, is_async=False):
debug.dbg('iterate %s', self)
@@ -239,8 +239,8 @@ class _ValueWrapperBase(HelperValueMixin):
return CompiledValueName(self, wrapped_name.string_name)
@classmethod
@infer_state_as_method_param_cache()
def create_cached(cls, infer_state, *args, **kwargs):
@inference_state_as_method_param_cache()
def create_cached(cls, inference_state, *args, **kwargs):
return cls(*args, **kwargs)
def __getattr__(self, name):
@@ -271,8 +271,8 @@ class ValueWrapper(_ValueWrapperBase):
class TreeValue(Value):
def __init__(self, infer_state, parent_context, tree_node):
super(TreeValue, self).__init__(infer_state, parent_context)
def __init__(self, inference_state, parent_context, tree_node):
super(TreeValue, self).__init__(inference_state, parent_context)
self.predefined_names = {}
self.tree_node = tree_node
@@ -398,7 +398,7 @@ class ValueSet(BaseValueSet):
)
def execute(self, arguments):
return ValueSet.from_sets(c.infer_state.execute(c, arguments) for c in self._set)
return ValueSet.from_sets(c.inference_state.execute(c, arguments) for c in self._set)
def execute_with_values(self, *args, **kwargs):
return ValueSet.from_sets(c.execute_with_values(*args, **kwargs) for c in self._set)

24
jedi/inference/cache.py
View File

@@ -10,7 +10,7 @@ _NO_DEFAULT = object()
_RECURSION_SENTINEL = object()
def _memoize_default(default=_NO_DEFAULT, infer_state_is_first_arg=False, second_arg_is_infer_state=False):
def _memoize_default(default=_NO_DEFAULT, inference_state_is_first_arg=False, second_arg_is_inference_state=False):
""" This is a typical memoization decorator, BUT there is one difference:
To prevent recursion it sets defaults.
@@ -21,12 +21,12 @@ def _memoize_default(default=_NO_DEFAULT, infer_state_is_first_arg=False, second
def func(function):
def wrapper(obj, *args, **kwargs):
# TODO These checks are kind of ugly and slow.
if infer_state_is_first_arg:
if inference_state_is_first_arg:
cache = obj.memoize_cache
elif second_arg_is_infer_state:
elif second_arg_is_inference_state:
cache = args[0].memoize_cache # needed for meta classes
else:
cache = obj.infer_state.memoize_cache
cache = obj.inference_state.memoize_cache
try:
memo = cache[function]
@@ -47,23 +47,23 @@ def _memoize_default(default=_NO_DEFAULT, infer_state_is_first_arg=False, second
return func
def infer_state_function_cache(default=_NO_DEFAULT):
def inference_state_function_cache(default=_NO_DEFAULT):
def decorator(func):
return _memoize_default(default=default, infer_state_is_first_arg=True)(func)
return _memoize_default(default=default, inference_state_is_first_arg=True)(func)
return decorator
def infer_state_method_cache(default=_NO_DEFAULT):
def inference_state_method_cache(default=_NO_DEFAULT):
def decorator(func):
return _memoize_default(default=default)(func)
return decorator
def infer_state_as_method_param_cache():
def inference_state_as_method_param_cache():
def decorator(call):
return _memoize_default(second_arg_is_infer_state=True)(call)
return _memoize_default(second_arg_is_inference_state=True)(call)
return decorator
@@ -74,19 +74,19 @@ class CachedMetaClass(type):
class initializations. Either you do it this way or with decorators, but
with decorators you lose class access (isinstance, etc).
"""
@infer_state_as_method_param_cache()
@inference_state_as_method_param_cache()
def __call__(self, *args, **kwargs):
return super(CachedMetaClass, self).__call__(*args, **kwargs)
def infer_state_method_generator_cache():
def inference_state_method_generator_cache():
"""
This is a special memoizer. It memoizes generators and also checks for
recursion errors and returns no further iterator elemends in that case.
"""
def func(function):
def wrapper(obj, *args, **kwargs):
cache = obj.infer_state.memoize_cache
cache = obj.inference_state.memoize_cache
try:
memo = cache[function]
except KeyError:

24
jedi/inference/compiled/__init__.py
View File

@@ -4,8 +4,8 @@ from jedi.inference.compiled.value import CompiledObject, CompiledName, \
from jedi.inference.base_value import ValueWrapper, LazyValueWrapper
def builtin_from_name(infer_state, string):
typing_builtins_module = infer_state.builtins_module
def builtin_from_name(inference_state, string):
typing_builtins_module = inference_state.builtins_module
if string in ('None', 'True', 'False'):
builtins, = typing_builtins_module.non_stub_value_set
filter_ = next(builtins.get_filters())
@@ -18,7 +18,7 @@ def builtin_from_name(infer_state, string):
class CompiledValue(LazyValueWrapper):
def __init__(self, compiled_obj):
self.infer_state = compiled_obj.infer_state
self.inference_state = compiled_obj.inference_state
self._compiled_obj = compiled_obj
def __getattribute__(self, name):
@@ -29,36 +29,36 @@ class CompiledValue(LazyValueWrapper):
def _get_wrapped_value(self):
instance, = builtin_from_name(
self.infer_state, self._compiled_obj.name.string_name).execute_with_values()
self.inference_state, self._compiled_obj.name.string_name).execute_with_values()
return instance
def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self._compiled_obj)
def create_simple_object(infer_state, obj):
def create_simple_object(inference_state, obj):
"""
Only allows creations of objects that are easily picklable across Python
versions.
"""
assert type(obj) in (int, float, str, bytes, unicode, slice, complex, bool), obj
compiled_obj = create_from_access_path(
infer_state,
infer_state.compiled_subprocess.create_simple_object(obj)
inference_state,
inference_state.compiled_subprocess.create_simple_object(obj)
)
return CompiledValue(compiled_obj)
def get_string_value_set(infer_state):
return builtin_from_name(infer_state, u'str').execute_with_values()
def get_string_value_set(inference_state):
return builtin_from_name(inference_state, u'str').execute_with_values()
def load_module(infer_state, dotted_name, **kwargs):
def load_module(inference_state, dotted_name, **kwargs):
# Temporary, some tensorflow builtins cannot be loaded, so it's tried again
# and again and it's really slow.
if dotted_name.startswith('tensorflow.'):
return None
access_path = infer_state.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs)
access_path = inference_state.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs)
if access_path is None:
return None
return create_from_access_path(infer_state, access_path)
return create_from_access_path(inference_state, access_path)

30
jedi/inference/compiled/access.py
View File

@@ -109,8 +109,8 @@ def compiled_objects_cache(attribute_name):
Caching the id has the advantage that an object doesn't need to be
hashable.
"""
def wrapper(infer_state, obj, parent_context=None):
cache = getattr(infer_state, attribute_name)
def wrapper(inference_state, obj, parent_context=None):
cache = getattr(inference_state, attribute_name)
# Do a very cheap form of caching here.
key = id(obj)
try:
@@ -119,9 +119,9 @@ def compiled_objects_cache(attribute_name):
except KeyError:
# TODO wuaaaarrghhhhhhhh
if attribute_name == 'mixed_cache':
result = func(infer_state, obj, parent_context)
result = func(inference_state, obj, parent_context)
else:
result = func(infer_state, obj)
result = func(inference_state, obj)
# Need to cache all of them, otherwise the id could be overwritten.
cache[key] = result, obj, parent_context
return result
@@ -130,11 +130,11 @@ def compiled_objects_cache(attribute_name):
return decorator
def create_access(infer_state, obj):
return infer_state.compiled_subprocess.get_or_create_access_handle(obj)
def create_access(inference_state, obj):
return inference_state.compiled_subprocess.get_or_create_access_handle(obj)
def load_module(infer_state, dotted_name, sys_path):
def load_module(inference_state, dotted_name, sys_path):
temp, sys.path = sys.path, sys_path
try:
__import__(dotted_name)
@@ -154,7 +154,7 @@ def load_module(infer_state, dotted_name, sys_path):
# Just access the cache after import, because of #59 as well as the very
# complicated import structure of Python.
module = sys.modules[dotted_name]
return create_access_path(infer_state, module)
return create_access_path(inference_state, module)
class AccessPath(object):
@@ -171,8 +171,8 @@ class AccessPath(object):
self.accesses = value
def create_access_path(infer_state, obj):
access = create_access(infer_state, obj)
def create_access_path(inference_state, obj):
access = create_access(inference_state, obj)
return AccessPath(access.get_access_path_tuples())
@@ -193,18 +193,18 @@ def get_api_type(obj):
class DirectObjectAccess(object):
def __init__(self, infer_state, obj):
self._infer_state = infer_state
def __init__(self, inference_state, obj):
self._inference_state = inference_state
self._obj = obj
def __repr__(self):
return '%s(%s)' % (self.__class__.__name__, self.get_repr())
def _create_access(self, obj):
return create_access(self._infer_state, obj)
return create_access(self._inference_state, obj)
def _create_access_path(self, obj):
return create_access_path(self._infer_state, obj)
return create_access_path(self._inference_state, obj)
def py__bool__(self):
return bool(self._obj)
@@ -376,7 +376,7 @@ class DirectObjectAccess(object):
return get_api_type(self._obj)
def get_access_path_tuples(self):
accesses = [create_access(self._infer_state, o) for o in self._get_objects_path()]
accesses = [create_access(self._inference_state, o) for o in self._get_objects_path()]
return [(access.py__name__(), access) for access in accesses]
def _get_objects_path(self):

34
jedi/inference/compiled/mixed.py
View File

@@ -15,7 +15,7 @@ from jedi.file_io import FileIO
from jedi.inference.base_value import ValueSet, ValueWrapper
from jedi.inference.helpers import SimpleGetItemNotFound
from jedi.inference.value import ModuleValue
from jedi.inference.cache import infer_state_function_cache
from jedi.inference.cache import inference_state_function_cache
from jedi.inference.compiled.getattr_static import getattr_static
from jedi.inference.compiled.access import compiled_objects_cache, \
ALLOWED_GETITEM_TYPES, get_api_type
@@ -48,7 +48,7 @@ class MixedObject(ValueWrapper):
self.access_handle = compiled_object.access_handle
def get_filters(self, *args, **kwargs):
yield MixedObjectFilter(self.infer_state, self)
yield MixedObjectFilter(self.inference_state, self)
def get_signatures(self):
# Prefer `inspect.signature` over somehow analyzing Python code. It
@@ -105,9 +105,9 @@ class MixedName(compiled.CompiledName):
values = [None]
for access in access_paths:
values = ValueSet.from_sets(
_create(self._infer_state, access, parent_context=c)
_create(self._inference_state, access, parent_context=c)
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.inference_state, access, c)})
for c in values
)
return values
@@ -121,9 +121,9 @@ class MixedObjectFilter(compiled.CompiledObjectFilter):
name_class = MixedName
@infer_state_function_cache()
def _load_module(infer_state, path):
module_node = infer_state.parse(
@inference_state_function_cache()
def _load_module(inference_state, path):
module_node = inference_state.parse(
path=path,
cache=True,
diff_cache=settings.fast_parser,
@@ -131,7 +131,7 @@ def _load_module(infer_state, path):
).get_root_node()
# python_module = inspect.getmodule(python_object)
# TODO we should actually make something like this possible.
#infer_state.modules[python_module.__name__] = module_node
#inference_state.modules[python_module.__name__] = module_node
return module_node
@@ -155,7 +155,7 @@ def _get_object_to_check(python_object):
raise TypeError # Prevents computation of `repr` within inspect.
def _find_syntax_node_name(infer_state, python_object):
def _find_syntax_node_name(inference_state, python_object):
original_object = python_object
try:
python_object = _get_object_to_check(python_object)
@@ -168,13 +168,13 @@ def _find_syntax_node_name(infer_state, python_object):
return None
file_io = FileIO(path)
module_node = _load_module(infer_state, path)
module_node = _load_module(inference_state, path)
if inspect.ismodule(python_object):
# We don't need to check names for modules, because there's not really
# a way to write a module in a module in Python (and also __name__ can
# be something like ``email.utils``).
code_lines = get_cached_code_lines(infer_state.grammar, path)
code_lines = get_cached_code_lines(inference_state.grammar, path)
return module_node, module_node, file_io, code_lines
try:
@@ -214,7 +214,7 @@ def _find_syntax_node_name(infer_state, python_object):
if line_names:
names = line_names
code_lines = get_cached_code_lines(infer_state.grammar, path)
code_lines = get_cached_code_lines(inference_state.grammar, path)
# It's really hard to actually get the right definition, here as a last
# resort we just return the last one. This chance might lead to odd
# completions at some points but will lead to mostly correct type
@@ -230,9 +230,9 @@ def _find_syntax_node_name(infer_state, python_object):
@compiled_objects_cache('mixed_cache')
def _create(infer_state, access_handle, parent_context, *args):
def _create(inference_state, access_handle, parent_context, *args):
compiled_object = create_cached_compiled_object(
infer_state,
inference_state,
access_handle,
parent_context=parent_context and parent_context.compiled_object
)
@@ -240,7 +240,7 @@ def _create(infer_state, access_handle, parent_context, *args):
# TODO accessing this is bad, but it probably doesn't matter that much,
# because we're working with interpreteters only here.
python_object = access_handle.access._obj
result = _find_syntax_node_name(infer_state, python_object)
result = _find_syntax_node_name(inference_state, python_object)
if result is None:
# TODO Care about generics from stuff like `[1]` and don't return like this.
if type(python_object) in (dict, list, tuple):
@@ -257,14 +257,14 @@ def _create(infer_state, access_handle, parent_context, *args):
name = compiled_object.get_root_value().py__name__()
string_names = tuple(name.split('.'))
module_value = ModuleValue(
infer_state, module_node,
inference_state, module_node,
file_io=file_io,
string_names=string_names,
code_lines=code_lines,
is_package=hasattr(compiled_object, 'py__path__'),
)
if name is not None:
infer_state.module_cache.add(string_names, ValueSet([module_value]))
inference_state.module_cache.add(string_names, ValueSet([module_value]))
else:
if parent_context.tree_node.get_root_node() != module_node:
# This happens e.g. when __module__ is wrong, or when using

70
jedi/inference/compiled/subprocess/__init__.py
View File

@@ -71,9 +71,9 @@ def _cleanup_process(process, thread):
class _InferenceStateProcess(object):
def __init__(self, infer_state):
self._infer_state_weakref = weakref.ref(infer_state)
self._infer_state_id = id(infer_state)
def __init__(self, inference_state):
self._inference_state_weakref = weakref.ref(inference_state)
self._inference_state_id = id(inference_state)
self._handles = {}
def get_or_create_access_handle(self, obj):
@@ -81,7 +81,7 @@ class _InferenceStateProcess(object):
try:
return self.get_access_handle(id_)
except KeyError:
access = DirectObjectAccess(self._infer_state_weakref(), obj)
access = DirectObjectAccess(self._inference_state_weakref(), obj)
handle = AccessHandle(self, access, id_)
self.set_access_handle(handle)
return handle
@@ -100,12 +100,12 @@ class InferenceStateSameProcess(_InferenceStateProcess):
This is necessary for the Interpreter process.
"""
def __getattr__(self, name):
return partial(_get_function(name), self._infer_state_weakref())
return partial(_get_function(name), self._inference_state_weakref())
class InferenceStateSubprocess(_InferenceStateProcess):
def __init__(self, infer_state, compiled_subprocess):
super(InferenceStateSubprocess, self).__init__(infer_state)
def __init__(self, inference_state, compiled_subprocess):
super(InferenceStateSubprocess, self).__init__(inference_state)
self._used = False
self._compiled_subprocess = compiled_subprocess
@@ -116,7 +116,7 @@ class InferenceStateSubprocess(_InferenceStateProcess):
self._used = True
result = self._compiled_subprocess.run(
self._infer_state_weakref(),
self._inference_state_weakref(),
func,
args=args,
kwargs=kwargs,
@@ -148,7 +148,7 @@ class InferenceStateSubprocess(_InferenceStateProcess):
def __del__(self):
if self._used and not self._compiled_subprocess.is_crashed:
self._compiled_subprocess.delete_infer_state(self._infer_state_id)
self._compiled_subprocess.delete_inference_state(self._inference_state_id)
class CompiledSubprocess(object):
@@ -158,7 +158,7 @@ class CompiledSubprocess(object):
def __init__(self, executable):
self._executable = executable
self._infer_state_deletion_queue = queue.deque()
self._inference_state_deletion_queue = queue.deque()
self._cleanup_callable = lambda: None
def __repr__(self):
@@ -205,18 +205,18 @@ class CompiledSubprocess(object):
t)
return process
def run(self, infer_state, function, args=(), kwargs={}):
# Delete old infer_states.
def run(self, inference_state, function, args=(), kwargs={}):
# Delete old inference_states.
while True:
try:
infer_state_id = self._infer_state_deletion_queue.pop()
inference_state_id = self._inference_state_deletion_queue.pop()
except IndexError:
break
else:
self._send(infer_state_id, None)
self._send(inference_state_id, None)
assert callable(function)
return self._send(id(infer_state), function, args, kwargs)
return self._send(id(inference_state), function, args, kwargs)
def get_sys_path(self):
return self._send(None, functions.get_sys_path, (), {})
@@ -225,7 +225,7 @@ class CompiledSubprocess(object):
self.is_crashed = True
self._cleanup_callable()
def _send(self, infer_state_id, function, args=(), kwargs={}):
def _send(self, inference_state_id, function, args=(), kwargs={}):
if self.is_crashed:
raise InternalError("The subprocess %s has crashed." % self._executable)
@@ -233,7 +233,7 @@ class CompiledSubprocess(object):
# Python 2 compatibility
kwargs = {force_unicode(key): value for key, value in kwargs.items()}
data = infer_state_id, function, args, kwargs
data = inference_state_id, function, args, kwargs
try:
pickle_dump(data, self._get_process().stdin, self._pickle_protocol)
except (socket.error, IOError) as e:
@@ -272,59 +272,59 @@ class CompiledSubprocess(object):
raise result
return result
def delete_infer_state(self, infer_state_id):
def delete_inference_state(self, inference_state_id):
"""
Currently we are not deleting infer_state instantly. They only get
Currently we are not deleting inference_state instantly. They only get
deleted once the subprocess is used again. It would probably a better
solution to move all of this into a thread. However, the memory usage
of a single infer_state shouldn't be that high.
of a single inference_state shouldn't be that high.
"""
# With an argument - the infer_state gets deleted.
self._infer_state_deletion_queue.append(infer_state_id)
# With an argument - the inference_state gets deleted.
self._inference_state_deletion_queue.append(inference_state_id)
class Listener(object):
def __init__(self, pickle_protocol):
self._infer_states = {}
self._inference_states = {}
# TODO refactor so we don't need to process anymore just handle
# controlling.
self._process = _InferenceStateProcess(Listener)
self._pickle_protocol = pickle_protocol
def _get_infer_state(self, function, infer_state_id):
def _get_inference_state(self, function, inference_state_id):
from jedi.inference import InferenceState
try:
infer_state = self._infer_states[infer_state_id]
inference_state = self._inference_states[inference_state_id]
except KeyError:
from jedi.api.environment import InterpreterEnvironment
infer_state = InferenceState(
inference_state = InferenceState(
# The project is not actually needed. Nothing should need to
# access it.
project=None,
environment=InterpreterEnvironment()
)
self._infer_states[infer_state_id] = infer_state
return infer_state
self._inference_states[inference_state_id] = inference_state
return inference_state
def _run(self, infer_state_id, function, args, kwargs):
if infer_state_id is None:
def _run(self, inference_state_id, function, args, kwargs):
if inference_state_id is None:
return function(*args, **kwargs)
elif function is None:
del self._infer_states[infer_state_id]
del self._inference_states[inference_state_id]
else:
infer_state = self._get_infer_state(function, infer_state_id)
inference_state = self._get_inference_state(function, inference_state_id)
# Exchange all handles
args = list(args)
for i, arg in enumerate(args):
if isinstance(arg, AccessHandle):
args[i] = infer_state.compiled_subprocess.get_access_handle(arg.id)
args[i] = inference_state.compiled_subprocess.get_access_handle(arg.id)
for key, value in kwargs.items():
if isinstance(value, AccessHandle):
kwargs[key] = infer_state.compiled_subprocess.get_access_handle(value.id)
kwargs[key] = inference_state.compiled_subprocess.get_access_handle(value.id)
return function(infer_state, *args, **kwargs)
return function(inference_state, *args, **kwargs)
def listen(self):
stdout = sys.stdout

24
jedi/inference/compiled/subprocess/functions.py
View File

@@ -12,20 +12,20 @@ def get_sys_path():
return list(map(cast_path, sys.path))
def load_module(infer_state, **kwargs):
return access.load_module(infer_state, **kwargs)
def load_module(inference_state, **kwargs):
return access.load_module(inference_state, **kwargs)
def get_compiled_method_return(infer_state, id, attribute, *args, **kwargs):
handle = infer_state.compiled_subprocess.get_access_handle(id)
def get_compiled_method_return(inference_state, id, attribute, *args, **kwargs):
handle = inference_state.compiled_subprocess.get_access_handle(id)
return getattr(handle.access, attribute)(*args, **kwargs)
def create_simple_object(infer_state, obj):
return access.create_access_path(infer_state, obj)
def create_simple_object(inference_state, obj):
return access.create_access_path(inference_state, obj)
def get_module_info(infer_state, sys_path=None, full_name=None, **kwargs):
def get_module_info(inference_state, sys_path=None, full_name=None, **kwargs):
"""
Returns Tuple[Union[NamespaceInfo, FileIO, None], Optional[bool]]
"""
@@ -40,25 +40,25 @@ def get_module_info(infer_state, sys_path=None, full_name=None, **kwargs):
sys.path = temp
def list_module_names(infer_state, search_path):
def list_module_names(inference_state, search_path):
return [
force_unicode(name)
for module_loader, name, is_pkg in iter_modules(search_path)
]
def get_builtin_module_names(infer_state):
def get_builtin_module_names(inference_state):
return list(map(force_unicode, sys.builtin_module_names))
def _test_raise_error(infer_state, exception_type):
def _test_raise_error(inference_state, exception_type):
"""
Raise an error to simulate certain problems for unit tests.
"""
raise exception_type
def _test_print(infer_state, stderr=None, stdout=None):
def _test_print(inference_state, stderr=None, stdout=None):
"""
Force some prints in the subprocesses. This exists for unit tests.
"""
@@ -82,5 +82,5 @@ def _get_init_path(directory_path):
return None
def safe_literal_eval(infer_state, value):
def safe_literal_eval(inference_state, value):
return parser_utils.safe_literal_eval(value)

80
jedi/inference/compiled/value.py
View File

@@ -14,7 +14,7 @@ from jedi.inference.names import AbstractNameDefinition, ValueNameMixin, \
from jedi.inference.base_value import Value, ValueSet, NO_VALUES
from jedi.inference.lazy_value import LazyKnownValue
from jedi.inference.compiled.access import _sentinel
from jedi.inference.cache import infer_state_function_cache
from jedi.inference.cache import inference_state_function_cache
from jedi.inference.helpers import reraise_getitem_errors
from jedi.inference.signature import BuiltinSignature
@@ -41,15 +41,15 @@ class CheckAttribute(object):
class CompiledObject(Value):
def __init__(self, infer_state, access_handle, parent_context=None):
super(CompiledObject, self).__init__(infer_state, parent_context)
def __init__(self, inference_state, access_handle, parent_context=None):
super(CompiledObject, self).__init__(inference_state, parent_context)
self.access_handle = access_handle
def py__call__(self, arguments):
return_annotation = self.access_handle.get_return_annotation()
if return_annotation is not None:
# TODO the return annotation may also be a string.
return create_from_access_path(self.infer_state, return_annotation).execute_annotation()
return create_from_access_path(self.inference_state, return_annotation).execute_annotation()
try:
self.access_handle.getattr_paths(u'__call__')
@@ -59,26 +59,26 @@ class CompiledObject(Value):
if self.access_handle.is_class():
from jedi.inference.value import CompiledInstance
return ValueSet([
CompiledInstance(self.infer_state, self.parent_context, self, arguments)
CompiledInstance(self.inference_state, self.parent_context, self, arguments)
])
else:
return ValueSet(self._execute_function(arguments))
@CheckAttribute()
def py__class__(self):
return create_from_access_path(self.infer_state, self.access_handle.py__class__())
return create_from_access_path(self.inference_state, self.access_handle.py__class__())
@CheckAttribute()
def py__mro__(self):
return (self,) + tuple(
create_from_access_path(self.infer_state, access)
create_from_access_path(self.inference_state, access)
for access in self.access_handle.py__mro__accesses()
)
@CheckAttribute()
def py__bases__(self):
return tuple(
create_from_access_path(self.infer_state, access)
create_from_access_path(self.inference_state, access)
for access in self.access_handle.py__bases__()
)
@@ -178,7 +178,7 @@ class CompiledObject(Value):
search_global shouldn't change the fact that there's one dict, this way
there's only one `object`.
"""
return CompiledObjectFilter(self.infer_state, self, is_instance)
return CompiledObjectFilter(self.inference_state, self, is_instance)
@CheckAttribute(u'__getitem__')
def py__simple_getitem__(self, index):
@@ -187,7 +187,7 @@ class CompiledObject(Value):
if access is None:
return NO_VALUES
return ValueSet([create_from_access_path(self.infer_state, access)])
return ValueSet([create_from_access_path(self.inference_state, access)])
def py__getitem__(self, index_value_set, valueualized_node):
all_access_paths = self.access_handle.py__getitem__all_values()
@@ -196,7 +196,7 @@ class CompiledObject(Value):
# object.
return super(CompiledObject, self).py__getitem__(index_value_set, valueualized_node)
return ValueSet(
create_from_access_path(self.infer_state, access)
create_from_access_path(self.inference_state, access)
for access in all_access_paths
)
@@ -215,7 +215,7 @@ class CompiledObject(Value):
return
for access in access_path_list:
yield LazyKnownValue(create_from_access_path(self.infer_state, access))
yield LazyKnownValue(create_from_access_path(self.inference_state, access))
def py__name__(self):
return self.access_handle.py__name__()
@@ -237,12 +237,12 @@ class CompiledObject(Value):
try:
# TODO wtf is this? this is exactly the same as the thing
# below. It uses getattr as well.
self.infer_state.builtins_module.access_handle.getattr_paths(name)
self.inference_state.builtins_module.access_handle.getattr_paths(name)
except AttributeError:
continue
else:
bltn_obj = builtin_from_name(self.infer_state, name)
for result in self.infer_state.execute(bltn_obj, params):
bltn_obj = builtin_from_name(self.inference_state, name)
for result in self.inference_state.execute(bltn_obj, params):
yield result
for type_ in docstrings.infer_return_types(self):
yield type_
@@ -257,20 +257,20 @@ class CompiledObject(Value):
def execute_operation(self, other, operator):
return create_from_access_path(
self.infer_state,
self.inference_state,
self.access_handle.execute_operation(other.access_handle, operator)
)
def negate(self):
return create_from_access_path(self.infer_state, self.access_handle.negate())
return create_from_access_path(self.inference_state, self.access_handle.negate())
def get_metaclasses(self):
return NO_VALUES
class CompiledName(AbstractNameDefinition):
def __init__(self, infer_state, parent_context, name):
self._infer_state = infer_state
def __init__(self, inference_state, parent_context, name):
self._inference_state = inference_state
self.parent_context = parent_context
self.string_name = name
@@ -296,7 +296,7 @@ class CompiledName(AbstractNameDefinition):
@underscore_memoization
def infer(self):
return ValueSet([_create_from_name(
self._infer_state, self.parent_context, self.string_name
self._inference_state, self.parent_context, self.string_name
)])
@@ -322,12 +322,12 @@ class SignatureParamName(ParamNameInterface, AbstractNameDefinition):
def infer(self):
p = self._signature_param
infer_state = self.parent_context.infer_state
inference_state = self.parent_context.inference_state
values = NO_VALUES
if p.has_default:
values = ValueSet([create_from_access_path(infer_state, p.default)])
values = ValueSet([create_from_access_path(inference_state, p.default)])
if p.has_annotation:
annotation = create_from_access_path(infer_state, p.annotation)
annotation = create_from_access_path(inference_state, p.annotation)
values |= annotation.execute_with_values()
return values
@@ -364,8 +364,8 @@ class EmptyCompiledName(AbstractNameDefinition):
completions, just give Jedi the option to return this object. It infers to
nothing.
"""
def __init__(self, infer_state, name):
self.parent_context = infer_state.builtins_module
def __init__(self, inference_state, name):
self.parent_context = inference_state.builtins_module
self.string_name = name
def infer(self):
@@ -375,8 +375,8 @@ class EmptyCompiledName(AbstractNameDefinition):
class CompiledObjectFilter(AbstractFilter):
name_class = CompiledName
def __init__(self, infer_state, compiled_object, is_instance=False):
self._infer_state = infer_state
def __init__(self, inference_state, compiled_object, is_instance=False):
self._inference_state = inference_state
self.compiled_object = compiled_object
self.is_instance = is_instance
@@ -399,7 +399,7 @@ class CompiledObjectFilter(AbstractFilter):
# Always use unicode objects in Python 2 from here.
name = force_unicode(name)
if (is_descriptor and not self._infer_state.allow_descriptor_getattr) or not has_attribute:
if (is_descriptor and not self._inference_state.allow_descriptor_getattr) or not has_attribute:
return [self._get_cached_name(name, is_empty=True)]
if self.is_instance and name not in dir_callback():
@@ -409,7 +409,7 @@ class CompiledObjectFilter(AbstractFilter):
@memoize_method
def _get_cached_name(self, name, is_empty=False):
if is_empty:
return EmptyCompiledName(self._infer_state, name)
return EmptyCompiledName(self._inference_state, name)
else:
return self._create_name(name)
@@ -426,12 +426,12 @@ class CompiledObjectFilter(AbstractFilter):
# ``dir`` doesn't include the type names.
if not self.is_instance and needs_type_completions:
for filter in builtin_from_name(self._infer_state, u'type').get_filters():
for filter in builtin_from_name(self._inference_state, u'type').get_filters():
names += filter.values()
return names
def _create_name(self, name):
return self.name_class(self._infer_state, self.compiled_object, name)
return self.name_class(self._inference_state, self.compiled_object, name)
def __repr__(self):
return "<%s: %s>" % (self.__class__.__name__, self.compiled_object)
@@ -507,7 +507,7 @@ def _parse_function_doc(doc):
return param_str, ret
def _create_from_name(infer_state, compiled_object, name):
def _create_from_name(inference_state, compiled_object, name):
access_paths = compiled_object.access_handle.getattr_paths(name, default=None)
parent_context = compiled_object
if parent_context.is_class():
@@ -516,26 +516,26 @@ def _create_from_name(infer_state, compiled_object, name):
value = None
for access_path in access_paths:
value = create_cached_compiled_object(
infer_state, access_path, parent_context=value
inference_state, access_path, parent_context=value
)
return value
def _normalize_create_args(func):
"""The cache doesn't care about keyword vs. normal args."""
def wrapper(infer_state, obj, parent_context=None):
return func(infer_state, obj, parent_context)
def wrapper(inference_state, obj, parent_context=None):
return func(inference_state, obj, parent_context)
return wrapper
def create_from_access_path(infer_state, access_path):
def create_from_access_path(inference_state, access_path):
parent_context = None
for name, access in access_path.accesses:
parent_context = create_cached_compiled_object(infer_state, access, parent_context)
parent_context = create_cached_compiled_object(inference_state, access, parent_context)
return parent_context
@_normalize_create_args
@infer_state_function_cache()
def create_cached_compiled_object(infer_state, access_handle, parent_context):
return CompiledObject(infer_state, access_handle, parent_context)
@inference_state_function_cache()
def create_cached_compiled_object(inference_state, access_handle, parent_context):
return CompiledObject(inference_state, access_handle, parent_context)

18
jedi/inference/docstrings.py
View File

@@ -24,7 +24,7 @@ from parso import parse, ParserSyntaxError
from jedi._compatibility import u
from jedi import debug
from jedi.inference.utils import indent_block
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.base_value import iterator_to_value_set, ValueSet, \
NO_VALUES
from jedi.inference.lazy_value import LazyKnownValues
@@ -205,7 +205,7 @@ def _infer_for_statement_string(module_value, string):
# will be impossible to use `...` (Ellipsis) as a token. Docstring types
# don't need to conform with the current grammar.
debug.dbg('Parse docstring code %s', string, color='BLUE')
grammar = module_value.infer_state.latest_grammar
grammar = module_value.inference_state.latest_grammar
try:
module = grammar.parse(code.format(indent_block(string)), error_recovery=False)
except ParserSyntaxError:
@@ -223,7 +223,7 @@ def _infer_for_statement_string(module_value, string):
from jedi.inference.value import FunctionValue
function_value = FunctionValue(
module_value.infer_state,
module_value.inference_state,
module_value,
funcdef
)
@@ -243,12 +243,12 @@ def _execute_types_in_stmt(module_value, stmt):
"""
definitions = module_value.infer_node(stmt)
return ValueSet.from_sets(
_execute_array_values(module_value.infer_state, d)
_execute_array_values(module_value.inference_state, d)
for d in definitions
)
def _execute_array_values(infer_state, array):
def _execute_array_values(inference_state, array):
"""
Tuples indicate that there's not just one return value, but the listed
ones. `(str, int)` means that it returns a tuple with both types.
@@ -258,16 +258,16 @@ def _execute_array_values(infer_state, array):
values = []
for lazy_value in array.py__iter__():
objects = ValueSet.from_sets(
_execute_array_values(infer_state, typ)
_execute_array_values(inference_state, typ)
for typ in lazy_value.infer()
)
values.append(LazyKnownValues(objects))
return {FakeSequence(infer_state, array.array_type, values)}
return {FakeSequence(inference_state, array.array_type, values)}
else:
return array.execute_annotation()
@infer_state_method_cache()
@inference_state_method_cache()
def infer_param(execution_value, param):
from jedi.inference.value.instance import InstanceArguments
from jedi.inference.value import FunctionExecutionValue
@@ -294,7 +294,7 @@ def infer_param(execution_value, param):
return types
@infer_state_method_cache()
@inference_state_method_cache()
@iterator_to_value_set
def infer_return_types(function_value):
def search_return_in_docstr(code):

42
jedi/inference/dynamic.py
View File

@@ -19,7 +19,7 @@ It works as follows:
from jedi import settings
from jedi import debug
from jedi.inference.cache import infer_state_function_cache
from jedi.inference.cache import inference_state_function_cache
from jedi.inference import imports
from jedi.inference.arguments import TreeArguments
from jedi.inference.param import create_default_params
@@ -39,12 +39,12 @@ class DynamicExecutedParams(object):
Simulates being a parameter while actually just being multiple params.
"""
def __init__(self, infer_state, executed_params):
self.infer_state = infer_state
def __init__(self, inference_state, executed_params):
self.inference_state = inference_state
self._executed_params = executed_params
def infer(self):
with recursion.execution_allowed(self.infer_state, self) as allowed:
with recursion.execution_allowed(self.inference_state, self) as allowed:
# We need to catch recursions that may occur, because an
# anonymous functions can create an anonymous parameter that is
# more or less self referencing.
@@ -54,7 +54,7 @@ class DynamicExecutedParams(object):
@debug.increase_indent
def search_params(infer_state, execution_value, funcdef):
def search_params(inference_state, execution_value, funcdef):
"""
A dynamic search for param values. If you try to complete a type:
@@ -70,7 +70,7 @@ def search_params(infer_state, execution_value, funcdef):
if not settings.dynamic_params:
return create_default_params(execution_value, funcdef)
infer_state.dynamic_params_depth += 1
inference_state.dynamic_params_depth += 1
try:
path = execution_value.get_root_value().py__file__()
if path is not None and is_stdlib_path(path):
@@ -91,7 +91,7 @@ def search_params(infer_state, execution_value, funcdef):
try:
module_value = execution_value.get_root_value()
function_executions = _search_function_executions(
infer_state,
inference_state,
module_value,
funcdef,
string_name=string_name,
@@ -101,7 +101,7 @@ def search_params(infer_state, execution_value, funcdef):
function_execution.get_executed_params_and_issues()[0]
for function_execution in function_executions
))
params = [DynamicExecutedParams(infer_state, executed_params)
params = [DynamicExecutedParams(inference_state, executed_params)
for executed_params in zipped_params]
# Inferes the ExecutedParams to types.
else:
@@ -110,12 +110,12 @@ def search_params(infer_state, execution_value, funcdef):
debug.dbg('Dynamic param result finished', color='MAGENTA')
return params
finally:
infer_state.dynamic_params_depth -= 1
inference_state.dynamic_params_depth -= 1
@infer_state_function_cache(default=None)
@inference_state_function_cache(default=None)
@to_list
def _search_function_executions(infer_state, module_value, funcdef, string_name):
def _search_function_executions(inference_state, module_value, funcdef, string_name):
"""
Returns a list of param names.
"""
@@ -129,7 +129,7 @@ def _search_function_executions(infer_state, module_value, funcdef, string_name)
found_executions = False
i = 0
for for_mod_value in imports.get_modules_containing_name(
infer_state, [module_value], string_name):
inference_state, [module_value], string_name):
if not isinstance(module_value, ModuleValue):
return
for name, trailer in _get_possible_nodes(for_mod_value, string_name):
@@ -138,12 +138,12 @@ def _search_function_executions(infer_state, module_value, funcdef, string_name)
# This is a simple way to stop Jedi's dynamic param recursion
# from going wild: The deeper Jedi's in the recursion, the less
# code should be inferred.
if i * infer_state.dynamic_params_depth > MAX_PARAM_SEARCHES:
if i * inference_state.dynamic_params_depth > MAX_PARAM_SEARCHES:
return
random_value = infer_state.create_value(for_mod_value, name)
random_value = inference_state.create_value(for_mod_value, name)
for function_execution in _check_name_for_execution(
infer_state, random_value, compare_node, name, trailer):
inference_state, random_value, compare_node, name, trailer):
found_executions = True
yield function_execution
@@ -178,17 +178,17 @@ def _get_possible_nodes(module_value, func_string_name):
yield name, trailer
def _check_name_for_execution(infer_state, value, compare_node, name, trailer):
def _check_name_for_execution(inference_state, value, compare_node, name, trailer):
from jedi.inference.value.function import FunctionExecutionValue
def create_func_excs():
arglist = trailer.children[1]
if arglist == ')':
arglist = None
args = TreeArguments(infer_state, value, arglist, trailer)
args = TreeArguments(inference_state, value, arglist, trailer)
if value_node.type == 'classdef':
created_instance = instance.TreeInstance(
infer_state,
inference_state,
v.parent_context,
v,
args
@@ -198,7 +198,7 @@ def _check_name_for_execution(infer_state, value, compare_node, name, trailer):
else:
yield v.get_function_execution(args)
for v in infer_state.goto_definitions(value, name):
for v in inference_state.goto_definitions(value, name):
value_node = v.tree_node
if compare_node == value_node:
for func_execution in create_func_excs():
@@ -219,9 +219,9 @@ def _check_name_for_execution(infer_state, value, compare_node, name, trailer):
execution_value = next(create_func_excs())
for name, trailer in _get_possible_nodes(module_value, params[0].string_name):
if value_node.start_pos < name.start_pos < value_node.end_pos:
random_value = infer_state.create_value(execution_value, name)
random_value = inference_state.create_value(execution_value, name)
iterator = _check_name_for_execution(
infer_state,
inference_state,
random_value,
compare_node,
name,

14
jedi/inference/filters.py
View File

@@ -235,7 +235,7 @@ class _BuiltinMappedMethod(Value):
def __init__(self, builtin_value, method, builtin_func):
super(_BuiltinMappedMethod, self).__init__(
builtin_value.infer_state,
builtin_value.inference_state,
parent_context=builtin_value
)
self._method = method
@@ -260,7 +260,7 @@ class SpecialMethodFilter(DictFilter):
def __init__(self, parent_context, string_name, value, builtin_value):
callable_, python_version = value
if python_version is not None and \
python_version != parent_context.infer_state.environment.version_info.major:
python_version != parent_context.inference_state.environment.version_info.major:
raise KeyError
self.parent_context = parent_context
@@ -327,8 +327,8 @@ class _AttributeOverwriteMixin(object):
class LazyAttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
LazyValueWrapper)):
def __init__(self, infer_state):
self.infer_state = infer_state
def __init__(self, inference_state):
self.inference_state = inference_state
class AttributeOverwrite(use_metaclass(_OverwriteMeta, _AttributeOverwriteMixin,
@@ -344,7 +344,7 @@ def publish_method(method_name, python_version_match=None):
return decorator
def get_global_filters(infer_state, value, until_position, origin_scope):
def get_global_filters(inference_state, value, until_position, origin_scope):
"""
Returns all filters in order of priority for name resolution.
@@ -363,7 +363,7 @@ def get_global_filters(infer_state, value, until_position, origin_scope):
>>> scope
<Function: func@3-5>
>>> value = script._get_module().create_value(scope)
>>> filters = list(get_global_filters(value.infer_state, value, (4, 0), None))
>>> filters = list(get_global_filters(value.inference_state, value, (4, 0), None))
First we get the names from the function scope.
@@ -407,4 +407,4 @@ def get_global_filters(infer_state, value, until_position, origin_scope):
value = value.parent_context
# Add builtins to the global scope.
yield next(infer_state.builtins_module.get_filters())
yield next(inference_state.builtins_module.get_filters())

12
jedi/inference/finder.py
View File

@@ -33,9 +33,9 @@ from jedi.inference.gradual.conversion import convert_values
class NameFinder(object):
def __init__(self, infer_state, value, name_value, name_or_str,
def __init__(self, inference_state, value, name_value, name_or_str,
position=None, analysis_errors=True):
self._infer_state = infer_state
self._inference_state = inference_state
# Make sure that it's not just a syntax tree node.
self._value = value
self._name_value = name_value
@@ -113,7 +113,7 @@ class NameFinder(object):
if lambdef is None or position < lambdef.children[-2].start_pos:
position = ancestor.start_pos
return get_global_filters(self._infer_state, self._value, position, origin_scope)
return get_global_filters(self._inference_state, self._value, position, origin_scope)
def get_value_filters(self):
origin_scope = self._get_origin_scope()
@@ -171,7 +171,7 @@ class NameFinder(object):
def _check_getattr(self, inst):
"""Checks for both __getattr__ and __getattribute__ methods"""
# str is important, because it shouldn't be `Name`!
name = compiled.create_simple_object(self._infer_state, self._string_name)
name = compiled.create_simple_object(self._inference_state, self._string_name)
# This is a little bit special. `__getattribute__` is in Python
# executed before `__getattr__`. But: I know no use case, where
@@ -263,7 +263,7 @@ def _check_isinstance_type(value, element, search_name):
# arglist stuff
arglist = trailer.children[1]
args = TreeArguments(value.infer_state, value, arglist, trailer)
args = TreeArguments(value.inference_state, value, arglist, trailer)
param_list = list(args.unpack())
# Disallow keyword arguments
assert len(param_list) == 2
@@ -273,7 +273,7 @@ def _check_isinstance_type(value, element, search_name):
is_instance_call = helpers.call_of_leaf(lazy_value_object.data)
# Do a simple get_code comparison. They should just have the same code,
# and everything will be all right.
normalize = value.infer_state.grammar._normalize
normalize = value.inference_state.grammar._normalize
assert normalize(is_instance_call) == normalize(call)
except AssertionError:
return None

2
jedi/inference/flow_analysis.py
View File

@@ -106,7 +106,7 @@ def _break_check(value, value_scope, flow_scope, node):
def _check_if(value, node):
with execution_allowed(value.infer_state, node) as allowed:
with execution_allowed(value.inference_state, node) as allowed:
if not allowed:
return UNSURE

16
jedi/inference/gradual/annotation.py
View File

@@ -10,7 +10,7 @@ import re
from parso import ParserSyntaxError, parse
from jedi._compatibility import force_unicode
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.base_value import ValueSet, NO_VALUES
from jedi.inference.gradual.typing import TypeVar, LazyGenericClass, \
AbstractAnnotatedClass
@@ -60,7 +60,7 @@ def _infer_annotation_string(value, string, index=None):
def _get_forward_reference_node(value, string):
try:
new_node = value.infer_state.grammar.parse(
new_node = value.inference_state.grammar.parse(
force_unicode(string),
start_symbol='eval_input',
error_recovery=False
@@ -106,21 +106,21 @@ def _split_comment_param_declaration(decl_text):
return params
@infer_state_method_cache()
@inference_state_method_cache()
def infer_param(execution_value, param):
values = _infer_param(execution_value, param)
infer_state = execution_value.infer_state
inference_state = execution_value.inference_state
if param.star_count == 1:
tuple_ = builtin_from_name(infer_state, 'tuple')
tuple_ = builtin_from_name(inference_state, 'tuple')
return ValueSet([GenericClass(
tuple_,
generics=(values,),
) for c in values])
elif param.star_count == 2:
dct = builtin_from_name(infer_state, 'dict')
dct = builtin_from_name(inference_state, 'dict')
return ValueSet([GenericClass(
dct,
generics=(ValueSet([builtin_from_name(infer_state, 'str')]), values),
generics=(ValueSet([builtin_from_name(inference_state, 'str')]), values),
) for c in values])
pass
return values
@@ -190,7 +190,7 @@ def py__annotations__(funcdef):
return dct
@infer_state_method_cache()
@inference_state_method_cache()
def infer_return_types(function_execution_value):
"""
Infers the type of a function's return value,

4
jedi/inference/gradual/conversion.py
View File

@@ -87,11 +87,11 @@ def _load_stub_module(module):
return module
from jedi.inference.gradual.typeshed import _try_to_load_stub_cached
return _try_to_load_stub_cached(
module.infer_state,
module.inference_state,
import_names=module.string_names,
python_value_set=ValueSet([module]),
parent_module_value=None,
sys_path=module.infer_state.get_sys_path(),
sys_path=module.inference_state.get_sys_path(),
)

52
jedi/inference/gradual/typeshed.py
View File

@@ -89,9 +89,9 @@ def _cache_stub_file_map(version_info):
def import_module_decorator(func):
@wraps(func)
def wrapper(infer_state, import_names, parent_module_value, sys_path, prefer_stubs):
def wrapper(inference_state, import_names, parent_module_value, sys_path, prefer_stubs):
try:
python_value_set = infer_state.module_cache.get(import_names)
python_value_set = inference_state.module_cache.get(import_names)
except KeyError:
if parent_module_value is not None and parent_module_value.is_stub():
parent_module_values = parent_module_value.non_stub_value_set
@@ -104,19 +104,19 @@ def import_module_decorator(func):
# ``os``.
python_parent = next(iter(parent_module_values))
if python_parent is None:
python_parent, = infer_state.import_module(('os',), prefer_stubs=False)
python_parent, = inference_state.import_module(('os',), prefer_stubs=False)
python_value_set = python_parent.py__getattribute__('path')
else:
python_value_set = ValueSet.from_sets(
func(infer_state, import_names, p, sys_path,)
func(inference_state, import_names, p, sys_path,)
for p in parent_module_values
)
infer_state.module_cache.add(import_names, python_value_set)
inference_state.module_cache.add(import_names, python_value_set)
if not prefer_stubs:
return python_value_set
stub = _try_to_load_stub_cached(infer_state, import_names, python_value_set,
stub = _try_to_load_stub_cached(inference_state, import_names, python_value_set,
parent_module_value, sys_path)
if stub is not None:
return ValueSet([stub])
@@ -125,21 +125,21 @@ def import_module_decorator(func):
return wrapper
def _try_to_load_stub_cached(infer_state, import_names, *args, **kwargs):
def _try_to_load_stub_cached(inference_state, import_names, *args, **kwargs):
try:
return infer_state.stub_module_cache[import_names]
return inference_state.stub_module_cache[import_names]
except KeyError:
pass
# TODO is this needed? where are the exceptions coming from that make this
# necessary? Just remove this line.
infer_state.stub_module_cache[import_names] = None
infer_state.stub_module_cache[import_names] = result = \
_try_to_load_stub(infer_state, import_names, *args, **kwargs)
inference_state.stub_module_cache[import_names] = None
inference_state.stub_module_cache[import_names] = result = \
_try_to_load_stub(inference_state, import_names, *args, **kwargs)
return result
def _try_to_load_stub(infer_state, import_names, python_value_set,
def _try_to_load_stub(inference_state, import_names, python_value_set,
parent_module_value, sys_path):
"""
Trying to load a stub for a set of import_names.
@@ -150,7 +150,7 @@ def _try_to_load_stub(infer_state, import_names, python_value_set,
if parent_module_value is None and len(import_names) > 1:
try:
parent_module_value = _try_to_load_stub_cached(
infer_state, import_names[:-1], NO_VALUES,
inference_state, import_names[:-1], NO_VALUES,
parent_module_value=None, sys_path=sys_path)
except KeyError:
pass
@@ -161,7 +161,7 @@ def _try_to_load_stub(infer_state, import_names, python_value_set,
for p in sys_path:
init = os.path.join(p, *import_names) + '-stubs' + os.path.sep + '__init__.pyi'
m = _try_to_load_stub_from_file(
infer_state,
inference_state,
python_value_set,
file_io=FileIO(init),
import_names=import_names,
@@ -185,7 +185,7 @@ def _try_to_load_stub(infer_state, import_names, python_value_set,
for file_path in file_paths:
m = _try_to_load_stub_from_file(
infer_state,
inference_state,
python_value_set,
# The file path should end with .pyi
file_io=FileIO(file_path),
@@ -195,7 +195,7 @@ def _try_to_load_stub(infer_state, import_names, python_value_set,
return m
# 3. Try to load typeshed
m = _load_from_typeshed(infer_state, python_value_set, parent_module_value, import_names)
m = _load_from_typeshed(inference_state, python_value_set, parent_module_value, import_names)
if m is not None:
return m
@@ -216,7 +216,7 @@ def _try_to_load_stub(infer_state, import_names, python_value_set,
for p in check_path:
m = _try_to_load_stub_from_file(
infer_state,
inference_state,
python_value_set,
file_io=FileIO(os.path.join(p, *names_for_path) + '.pyi'),
import_names=import_names,
@@ -229,11 +229,11 @@ def _try_to_load_stub(infer_state, import_names, python_value_set,
return None
def _load_from_typeshed(infer_state, python_value_set, parent_module_value, import_names):
def _load_from_typeshed(inference_state, python_value_set, parent_module_value, import_names):
import_name = import_names[-1]
map_ = None
if len(import_names) == 1:
map_ = _cache_stub_file_map(infer_state.grammar.version_info)
map_ = _cache_stub_file_map(inference_state.grammar.version_info)
import_name = _IMPORT_MAP.get(import_name, import_name)
elif isinstance(parent_module_value, StubModuleValue):
if not parent_module_value.is_package:
@@ -247,16 +247,16 @@ def _load_from_typeshed(infer_state, python_value_set, parent_module_value, impo
path = map_.get(import_name)
if path is not None:
return _try_to_load_stub_from_file(
infer_state,
inference_state,
python_value_set,
file_io=FileIO(path),
import_names=import_names,
)
def _try_to_load_stub_from_file(infer_state, python_value_set, file_io, import_names):
def _try_to_load_stub_from_file(inference_state, python_value_set, file_io, import_names):
try:
stub_module_node = infer_state.parse(
stub_module_node = inference_state.parse(
file_io=file_io,
cache=True,
use_latest_grammar=True
@@ -266,24 +266,24 @@ def _try_to_load_stub_from_file(infer_state, python_value_set, file_io, import_n
return None
else:
return create_stub_module(
infer_state, python_value_set, stub_module_node, file_io,
inference_state, python_value_set, stub_module_node, file_io,
import_names
)
def create_stub_module(infer_state, python_value_set, stub_module_node, file_io, import_names):
def create_stub_module(inference_state, python_value_set, stub_module_node, file_io, import_names):
if import_names == ('typing',):
module_cls = TypingModuleWrapper
else:
module_cls = StubModuleValue
file_name = os.path.basename(file_io.path)
stub_module_value = module_cls(
python_value_set, infer_state, stub_module_node,
python_value_set, inference_state, stub_module_node,
file_io=file_io,
string_names=import_names,
# The code was loaded with latest_grammar, so use
# that.
code_lines=get_cached_code_lines(infer_state.latest_grammar, file_io.path),
code_lines=get_cached_code_lines(inference_state.latest_grammar, file_io.path),
is_package=file_name == '__init__.pyi',
)
return stub_module_value

68
jedi/inference/gradual/typing.py
View File

@@ -7,7 +7,7 @@ This file deals with all the typing.py cases.
"""
from jedi._compatibility import unicode, force_unicode
from jedi import debug
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.compiled import builtin_from_name
from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \
iterator_to_value_set, ValueWrapper, LazyValueWrapper
@@ -45,8 +45,8 @@ class TypingName(AbstractTreeName):
class _BaseTypingValue(Value):
def __init__(self, infer_state, parent_context, tree_name):
super(_BaseTypingValue, self).__init__(infer_state, parent_context)
def __init__(self, inference_state, parent_context, tree_name):
super(_BaseTypingValue, self).__init__(inference_state, parent_context)
self._tree_name = tree_name
@property
@@ -71,7 +71,7 @@ class _BaseTypingValue(Value):
# TODO this is obviously not correct, but at least gives us a class if
# we have none. Some of these objects don't really have a base class in
# typeshed.
return builtin_from_name(self.infer_state, u'object')
return builtin_from_name(self.inference_state, u'object')
@property
def name(self):
@@ -87,39 +87,39 @@ class TypingModuleName(NameWrapper):
def _remap(self):
name = self.string_name
infer_state = self.parent_context.infer_state
inference_state = self.parent_context.inference_state
try:
actual = _TYPE_ALIAS_TYPES[name]
except KeyError:
pass
else:
yield TypeAlias.create_cached(infer_state, self.parent_context, self.tree_name, actual)
yield TypeAlias.create_cached(inference_state, self.parent_context, self.tree_name, actual)
return
if name in _PROXY_CLASS_TYPES:
yield TypingClassValue.create_cached(infer_state, self.parent_context, self.tree_name)
yield TypingClassValue.create_cached(inference_state, self.parent_context, self.tree_name)
elif name in _PROXY_TYPES:
yield TypingValue.create_cached(infer_state, self.parent_context, self.tree_name)
yield TypingValue.create_cached(inference_state, self.parent_context, self.tree_name)
elif name == 'runtime':
# We don't want anything here, not sure what this function is
# supposed to do, since it just appears in the stubs and shouldn't
# have any effects there (because it's never executed).
return
elif name == 'TypeVar':
yield TypeVarClass.create_cached(infer_state, self.parent_context, self.tree_name)
yield TypeVarClass.create_cached(inference_state, self.parent_context, self.tree_name)
elif name == 'Any':
yield Any.create_cached(infer_state, self.parent_context, self.tree_name)
yield Any.create_cached(inference_state, self.parent_context, self.tree_name)
elif name == 'TYPE_CHECKING':
# 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.
yield builtin_from_name(infer_state, u'True')
yield builtin_from_name(inference_state, u'True')
elif name == 'overload':
yield OverloadFunction.create_cached(infer_state, self.parent_context, self.tree_name)
yield OverloadFunction.create_cached(inference_state, self.parent_context, self.tree_name)
elif name == 'NewType':
yield NewTypeFunction.create_cached(infer_state, self.parent_context, self.tree_name)
yield NewTypeFunction.create_cached(inference_state, self.parent_context, self.tree_name)
elif name == 'cast':
# TODO implement cast
yield CastFunction.create_cached(infer_state, self.parent_context, self.tree_name)
yield CastFunction.create_cached(inference_state, self.parent_context, self.tree_name)
elif name == 'TypedDict':
# TODO doesn't even exist in typeshed/typing.py, yet. But will be
# added soon.
@@ -139,8 +139,8 @@ class TypingModuleFilterWrapper(FilterWrapper):
class _WithIndexBase(_BaseTypingValue):
def __init__(self, infer_state, parent_context, name, index_value, value_of_index):
super(_WithIndexBase, self).__init__(infer_state, parent_context, name)
def __init__(self, inference_state, parent_context, name, index_value, value_of_index):
super(_WithIndexBase, self).__init__(inference_state, parent_context, name)
self._index_value = index_value
self._value_of_index = value_of_index
@@ -164,7 +164,7 @@ class TypingValueWithIndex(_WithIndexBase):
# Optional is basically just saying it's either None or the actual
# type.
return self.gather_annotation_classes().execute_annotation() \
| ValueSet([builtin_from_name(self.infer_state, u'None')])
| ValueSet([builtin_from_name(self.inference_state, u'None')])
elif string_name == 'Type':
# The type is actually already given in the index_value
return ValueSet([self._index_value])
@@ -174,7 +174,7 @@ class TypingValueWithIndex(_WithIndexBase):
cls = globals()[string_name]
return ValueSet([cls(
self.infer_state,
self.inference_state,
self.parent_context,
self._tree_name,
self._index_value,
@@ -194,7 +194,7 @@ class TypingValue(_BaseTypingValue):
def py__getitem__(self, index_value_set, valueualized_node):
return ValueSet(
self.index_class.create_cached(
self.infer_state,
self.inference_state,
self.parent_context,
self._tree_name,
index_value,
@@ -206,7 +206,7 @@ class TypingValue(_BaseTypingValue):
class _TypingClassMixin(object):
def py__bases__(self):
return [LazyKnownValues(
self.infer_state.builtins_module.py__getattribute__('object')
self.inference_state.builtins_module.py__getattribute__('object')
)]
def get_metaclasses(self):
@@ -246,7 +246,7 @@ def _iter_over_arguments(maybe_tuple_value, defining_value):
class TypeAlias(LazyValueWrapper):
def __init__(self, parent_context, origin_tree_name, actual):
self.infer_state = parent_context.infer_state
self.inference_state = parent_context.inference_state
self.parent_context = parent_context
self._origin_tree_name = origin_tree_name
self._actual = actual # e.g. builtins.list
@@ -263,13 +263,13 @@ class TypeAlias(LazyValueWrapper):
def _get_wrapped_value(self):
module_name, class_name = self._actual.split('.')
if self.infer_state.environment.version_info.major == 2 and module_name == 'builtins':
if self.inference_state.environment.version_info.major == 2 and module_name == 'builtins':
module_name = '__builtin__'
# TODO use infer_state.import_module?
# TODO use inference_state.import_module?
from jedi.inference.imports import Importer
module, = Importer(
self.infer_state, [module_name], self.infer_state.builtins_module
self.inference_state, [module_name], self.inference_state.builtins_module
).follow()
classes = module.py__getattribute__(class_name)
# There should only be one, because it's code that we control.
@@ -358,7 +358,7 @@ class TypeVarClass(_BaseTypingValue):
return NO_VALUES
return ValueSet([TypeVar.create_cached(
self.infer_state,
self.inference_state,
self.parent_context,
self._tree_name,
var_name,
@@ -382,7 +382,7 @@ class TypeVarClass(_BaseTypingValue):
return None
else:
safe_value = method(default=None)
if self.infer_state.environment.version_info.major == 2:
if self.inference_state.environment.version_info.major == 2:
if isinstance(safe_value, bytes):
return force_unicode(safe_value)
if isinstance(safe_value, (str, unicode)):
@@ -391,8 +391,8 @@ class TypeVarClass(_BaseTypingValue):
class TypeVar(_BaseTypingValue):
def __init__(self, infer_state, parent_context, tree_name, var_name, unpacked_args):
super(TypeVar, self).__init__(infer_state, parent_context, tree_name)
def __init__(self, inference_state, parent_context, tree_name, var_name, unpacked_args):
super(TypeVar, self).__init__(inference_state, parent_context, tree_name)
self._var_name = var_name
self._constraints_lazy_values = []
@@ -469,7 +469,7 @@ class NewTypeFunction(_BaseTypingValue):
return NO_VALUES
return ValueSet(
NewType(
self.infer_state,
self.inference_state,
valueualized_node.value,
valueualized_node.node,
second_arg.infer(),
@@ -477,8 +477,8 @@ class NewTypeFunction(_BaseTypingValue):
class NewType(Value):
def __init__(self, infer_state, parent_context, tree_node, type_value_set):
super(NewType, self).__init__(infer_state, parent_context)
def __init__(self, inference_state, parent_context, tree_node, type_value_set):
super(NewType, self).__init__(inference_state, parent_context)
self._type_value_set = type_value_set
self.tree_node = tree_node
@@ -643,7 +643,7 @@ class LazyGenericClass(AbstractAnnotatedClass):
self._index_value = index_value
self._value_of_index = value_of_index
@infer_state_method_cache()
@inference_state_method_cache()
def get_generics(self):
return list(_iter_over_arguments(self._index_value, self._value_of_index))
@@ -668,7 +668,7 @@ class LazyAnnotatedBaseClass(object):
if isinstance(base, AbstractAnnotatedClass):
# Here we have to recalculate the given types.
yield GenericClass.create_cached(
base.infer_state,
base.inference_state,
base._wrapped_value,
tuple(self._remap_type_vars(base)),
)
@@ -703,5 +703,5 @@ class InstanceWrapper(ValueWrapper):
except IndexError:
pass
elif cls.py__name__() == 'Iterator':
return ValueSet([builtin_from_name(self.infer_state, u'None')])
return ValueSet([builtin_from_name(self.inference_state, u'None')])
return self._wrapped_value.py__stop_iteration_returns()

8
jedi/inference/gradual/utils.py
View File

@@ -3,7 +3,7 @@ import os
from jedi.inference.gradual.typeshed import TYPESHED_PATH, create_stub_module
def load_proper_stub_module(infer_state, file_io, import_names, module_node):
def load_proper_stub_module(inference_state, file_io, import_names, module_node):
"""
This function is given a random .pyi file and should return the proper
module.
@@ -20,13 +20,13 @@ def load_proper_stub_module(infer_state, file_io, import_names, module_node):
import_names = import_names[:-1]
if import_names is not None:
actual_value_set = infer_state.import_module(import_names, prefer_stubs=False)
actual_value_set = inference_state.import_module(import_names, prefer_stubs=False)
if not actual_value_set:
return None
stub = create_stub_module(
infer_state, actual_value_set, module_node, file_io, import_names
inference_state, actual_value_set, module_node, file_io, import_names
)
infer_state.stub_module_cache[import_names] = stub
inference_state.stub_module_cache[import_names] = stub
return stub
return None

8
jedi/inference/helpers.py
View File

@@ -66,7 +66,7 @@ def infer_call_of_leaf(value, leaf, cut_own_trailer=False):
trailer = leaf.parent
if trailer.type == 'fstring':
from jedi.inference import compiled
return compiled.get_string_value_set(value.infer_state)
return compiled.get_string_value_set(value.inference_state)
# The leaf may not be the last or first child, because there exist three
# different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples
@@ -195,7 +195,7 @@ def predefine_names(value, flow_scope, dct):
def is_string(value):
if value.infer_state.environment.version_info.major == 2:
if value.inference_state.environment.version_info.major == 2:
str_classes = (unicode, bytes)
else:
str_classes = (unicode,)
@@ -265,5 +265,5 @@ def parse_dotted_names(nodes, is_import_from, until_node=None):
return level, names
def values_from_qualified_names(infer_state, *names):
return infer_state.import_module(names[:-1]).py__getattribute__(names[-1])
def values_from_qualified_names(inference_state, *names):
return inference_state.import_module(names[:-1]).py__getattribute__(names[-1])

70
jedi/inference/imports.py
View File

@@ -28,7 +28,7 @@ from jedi.inference import helpers
from jedi.inference import compiled
from jedi.inference import analysis
from jedi.inference.utils import unite
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.names import ImportName, SubModuleName
from jedi.inference.base_value import ValueSet, NO_VALUES
from jedi.inference.gradual.typeshed import import_module_decorator
@@ -56,13 +56,13 @@ class ModuleCache(object):
# This memoization is needed, because otherwise we will infinitely loop on
# certain imports.
@infer_state_method_cache(default=NO_VALUES)
@inference_state_method_cache(default=NO_VALUES)
def infer_import(value, tree_name, is_goto=False):
module_value = value.get_root_value()
import_node = search_ancestor(tree_name, 'import_name', 'import_from')
import_path = import_node.get_path_for_name(tree_name)
from_import_name = None
infer_state = value.infer_state
inference_state = value.inference_state
try:
from_names = import_node.get_from_names()
except AttributeError:
@@ -75,7 +75,7 @@ def infer_import(value, tree_name, is_goto=False):
from_import_name = import_path[-1]
import_path = from_names
importer = Importer(infer_state, tuple(import_path),
importer = Importer(inference_state, tuple(import_path),
module_value, import_node.level)
types = importer.follow()
@@ -101,7 +101,7 @@ def infer_import(value, tree_name, is_goto=False):
if not types:
path = import_path + [from_import_name]
importer = Importer(infer_state, tuple(path),
importer = Importer(inference_state, tuple(path),
module_value, import_node.level)
types = importer.follow()
# goto only accepts `Name`
@@ -183,7 +183,7 @@ def _level_to_base_import_path(project_path, directory, level):
class Importer(object):
def __init__(self, infer_state, import_path, module_value, level=0):
def __init__(self, inference_state, import_path, module_value, level=0):
"""
An implementation similar to ``__import__``. Use `follow`
to actually follow the imports.
@@ -197,7 +197,7 @@ class Importer(object):
:param import_path: List of namespaces (strings or Names).
"""
debug.speed('import %s %s' % (import_path, module_value))
self._infer_state = infer_state
self._inference_state = inference_state
self.level = level
self.module_value = module_value
@@ -233,7 +233,7 @@ class Importer(object):
directory = os.path.dirname(path)
base_import_path, base_directory = _level_to_base_import_path(
self._infer_state.project._path, directory, level,
self._inference_state.project._path, directory, level,
)
if base_directory is None:
# Everything is lost, the relative import does point
@@ -265,11 +265,11 @@ class Importer(object):
return self._fixed_sys_path
sys_path_mod = (
self._infer_state.get_sys_path()
self._inference_state.get_sys_path()
+ sys_path.check_sys_path_modifications(self.module_value)
)
if self._infer_state.environment.version_info.major == 2:
if self._inference_state.environment.version_info.major == 2:
file_path = self.module_value.py__file__()
if file_path is not None:
# Python2 uses an old strange way of importing relative imports.
@@ -290,7 +290,7 @@ class Importer(object):
value_set = [None]
for i, name in enumerate(self.import_path):
value_set = ValueSet.from_sets([
self._infer_state.import_module(
self._inference_state.import_module(
import_names[:i+1],
parent_module_value,
sys_path
@@ -311,12 +311,12 @@ class Importer(object):
# add builtin module names
if search_path is None and in_module is None:
names += [ImportName(self.module_value, name)
for name in self._infer_state.compiled_subprocess.get_builtin_module_names()]
for name in self._inference_state.compiled_subprocess.get_builtin_module_names()]
if search_path is None:
search_path = self._sys_path_with_modifications()
for name in iter_module_names(self._infer_state, search_path):
for name in iter_module_names(self._inference_state, search_path):
if in_module is None:
n = ImportName(self.module_value, name)
else:
@@ -324,7 +324,7 @@ class Importer(object):
names.append(n)
return names
def completion_names(self, infer_state, only_modules=False):
def completion_names(self, inference_state, only_modules=False):
"""
:param only_modules: Indicates wheter it's possible to import a
definition that is not defined in a module.
@@ -374,12 +374,12 @@ class Importer(object):
@plugin_manager.decorate()
@import_module_decorator
def import_module(infer_state, import_names, parent_module_value, sys_path):
def import_module(inference_state, import_names, parent_module_value, sys_path):
"""
This method is very similar to importlib's `_gcd_import`.
"""
if import_names[0] in settings.auto_import_modules:
module = _load_builtin_module(infer_state, import_names, sys_path)
module = _load_builtin_module(inference_state, import_names, sys_path)
if module is None:
return NO_VALUES
return ValueSet([module])
@@ -388,7 +388,7 @@ def import_module(infer_state, import_names, parent_module_value, sys_path):
if parent_module_value is None:
# Override the sys.path. It works only good that way.
# Injecting the path directly into `find_module` did not work.
file_io_or_ns, is_pkg = infer_state.compiled_subprocess.get_module_info(
file_io_or_ns, is_pkg = inference_state.compiled_subprocess.get_module_info(
string=import_names[-1],
full_name=module_name,
sys_path=sys_path,
@@ -409,7 +409,7 @@ def import_module(infer_state, import_names, parent_module_value, sys_path):
# not important to be correct.
if not isinstance(path, list):
path = [path]
file_io_or_ns, is_pkg = infer_state.compiled_subprocess.get_module_info(
file_io_or_ns, is_pkg = inference_state.compiled_subprocess.get_module_info(
string=import_names[-1],
path=path,
full_name=module_name,
@@ -423,17 +423,17 @@ def import_module(infer_state, import_names, parent_module_value, sys_path):
if isinstance(file_io_or_ns, ImplicitNSInfo):
from jedi.inference.value.namespace import ImplicitNamespaceValue
module = ImplicitNamespaceValue(
infer_state,
inference_state,
fullname=file_io_or_ns.name,
paths=file_io_or_ns.paths,
)
elif file_io_or_ns is None:
module = _load_builtin_module(infer_state, import_names, sys_path)
module = _load_builtin_module(inference_state, import_names, sys_path)
if module is None:
return NO_VALUES
else:
module = _load_python_module(
infer_state, file_io_or_ns, sys_path,
inference_state, file_io_or_ns, sys_path,
import_names=import_names,
is_package=is_pkg,
)
@@ -445,14 +445,14 @@ def import_module(infer_state, import_names, parent_module_value, sys_path):
return ValueSet([module])
def _load_python_module(infer_state, file_io, sys_path=None,
def _load_python_module(inference_state, file_io, sys_path=None,
import_names=None, is_package=False):
try:
return infer_state.module_cache.get_from_path(file_io.path)
return inference_state.module_cache.get_from_path(file_io.path)
except KeyError:
pass
module_node = infer_state.parse(
module_node = inference_state.parse(
file_io=file_io,
cache=True,
diff_cache=settings.fast_parser,
@@ -461,21 +461,21 @@ def _load_python_module(infer_state, file_io, sys_path=None,
from jedi.inference.value import ModuleValue
return ModuleValue(
infer_state, module_node,
inference_state, module_node,
file_io=file_io,
string_names=import_names,
code_lines=get_cached_code_lines(infer_state.grammar, file_io.path),
code_lines=get_cached_code_lines(inference_state.grammar, file_io.path),
is_package=is_package,
)
def _load_builtin_module(infer_state, import_names=None, sys_path=None):
def _load_builtin_module(inference_state, import_names=None, sys_path=None):
if sys_path is None:
sys_path = infer_state.get_sys_path()
sys_path = inference_state.get_sys_path()
dotted_name = '.'.join(import_names)
assert dotted_name is not None
module = compiled.load_module(infer_state, dotted_name=dotted_name, sys_path=sys_path)
module = compiled.load_module(inference_state, dotted_name=dotted_name, sys_path=sys_path)
if module is None:
# The file might raise an ImportError e.g. and therefore not be
# importable.
@@ -483,13 +483,13 @@ def _load_builtin_module(infer_state, import_names=None, sys_path=None):
return module
def _load_module_from_path(infer_state, file_io, base_names):
def _load_module_from_path(inference_state, file_io, base_names):
"""
This should pretty much only be used for get_modules_containing_name. It's
here to ensure that a random path is still properly loaded into the Jedi
module structure.
"""
e_sys_path = infer_state.get_sys_path()
e_sys_path = inference_state.get_sys_path()
path = file_io.path
if base_names:
module_name = os.path.basename(path)
@@ -503,16 +503,16 @@ def _load_module_from_path(infer_state, file_io, base_names):
import_names, is_package = sys_path.transform_path_to_dotted(e_sys_path, path)
module = _load_python_module(
infer_state, file_io,
inference_state, file_io,
sys_path=e_sys_path,
import_names=import_names,
is_package=is_package,
)
infer_state.module_cache.add(import_names, ValueSet([module]))
inference_state.module_cache.add(import_names, ValueSet([module]))
return module
def get_modules_containing_name(infer_state, modules, name):
def get_modules_containing_name(inference_state, modules, name):
"""
Search a name in the directories of modules.
"""
@@ -530,7 +530,7 @@ def get_modules_containing_name(infer_state, modules, name):
if name not in code:
return None
new_file_io = KnownContentFileIO(file_io.path, code)
m = _load_module_from_path(infer_state, new_file_io, base_names)
m = _load_module_from_path(inference_state, new_file_io, base_names)
if isinstance(m, compiled.CompiledObject):
return None
return m

12
jedi/inference/names.py
View File

@@ -66,10 +66,10 @@ class AbstractArbitraryName(AbstractNameDefinition):
"""
is_value_name = False
def __init__(self, infer_state, string):
self.infer_state = infer_state
def __init__(self, inference_state, string):
self.inference_state = inference_state
self.string_name = string
self.parent_context = infer_state.builtins_module
self.parent_context = inference_state.builtins_module
def infer(self):
return NO_VALUES
@@ -103,7 +103,7 @@ class AbstractTreeName(AbstractNameDefinition):
return parent_names + (self.tree_name.value,)
def goto(self, **kwargs):
return self.parent_context.infer_state.goto(self.parent_context, self.tree_name, **kwargs)
return self.parent_context.inference_state.goto(self.parent_context, self.tree_name, **kwargs)
def is_import(self):
imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
@@ -157,7 +157,7 @@ class TreeNameDefinition(AbstractTreeName):
# Refactor this, should probably be here.
from jedi.inference.syntax_tree import tree_name_to_values
parent = self.parent_context
return tree_name_to_values(parent.infer_state, parent, self.tree_name)
return tree_name_to_values(parent.inference_state, parent, self.tree_name)
@property
def api_type(self):
@@ -346,7 +346,7 @@ class ImportName(AbstractNameDefinition):
def infer(self):
from jedi.inference.imports import Importer
m = self._from_module_value
return Importer(m.infer_state, [self.string_name], m, level=self._level).follow()
return Importer(m.inference_state, [self.string_name], m, level=self._level).follow()
def goto(self):
return [m.name for m in self.infer()]

8
jedi/inference/param.py
View File

@@ -145,13 +145,13 @@ def get_executed_params_and_issues(execution_value, arguments):
var_arg_iterator.push_back((key, argument))
break
lazy_value_list.append(argument)
seq = iterable.FakeSequence(execution_value.infer_state, u'tuple', lazy_value_list)
seq = iterable.FakeSequence(execution_value.inference_state, u'tuple', lazy_value_list)
result_arg = LazyKnownValue(seq)
elif param.star_count == 2:
if argument is not None:
too_many_args(argument)
# **kwargs param
dct = iterable.FakeDict(execution_value.infer_state, dict(non_matching_keys))
dct = iterable.FakeDict(execution_value.inference_state, dict(non_matching_keys))
result_arg = LazyKnownValue(dct)
non_matching_keys = {}
else:
@@ -235,11 +235,11 @@ def _error_argument_count(funcdef, actual_count):
def _create_default_param(execution_value, param):
if param.star_count == 1:
result_arg = LazyKnownValue(
iterable.FakeSequence(execution_value.infer_state, u'tuple', [])
iterable.FakeSequence(execution_value.inference_state, u'tuple', [])
)
elif param.star_count == 2:
result_arg = LazyKnownValue(
iterable.FakeDict(execution_value.infer_state, {})
iterable.FakeDict(execution_value.inference_state, {})
)
elif param.default is None:
result_arg = LazyUnknownValue()

6
jedi/inference/parser_cache.py
View File

@@ -1,6 +1,6 @@
from jedi.inference.cache import infer_state_function_cache
from jedi.inference.cache import inference_state_function_cache
@infer_state_function_cache()
def get_yield_exprs(infer_state, funcdef):
@inference_state_function_cache()
def get_yield_exprs(inference_state, funcdef):
return list(funcdef.iter_yield_exprs())

12
jedi/inference/recursion.py
View File

@@ -56,12 +56,12 @@ class RecursionDetector(object):
@contextmanager
def execution_allowed(infer_state, node):
def execution_allowed(inference_state, node):
"""
A decorator to detect recursions in statements. In a recursion a statement
at the same place, in the same module may not be executed two times.
"""
pushed_nodes = infer_state.recursion_detector.pushed_nodes
pushed_nodes = inference_state.recursion_detector.pushed_nodes
if node in pushed_nodes:
debug.warning('catched stmt recursion: %s @%s', node,
@@ -78,7 +78,7 @@ def execution_allowed(infer_state, node):
def execution_recursion_decorator(default=NO_VALUES):
def decorator(func):
def wrapper(self, **kwargs):
detector = self.infer_state.execution_recursion_detector
detector = self.inference_state.execution_recursion_detector
limit_reached = detector.push_execution(self)
try:
if limit_reached:
@@ -96,8 +96,8 @@ class ExecutionRecursionDetector(object):
"""
Catches recursions of executions.
"""
def __init__(self, infer_state):
self._infer_state = infer_state
def __init__(self, inference_state):
self._inference_state = inference_state
self._recursion_level = 0
self._parent_execution_funcs = []
@@ -117,7 +117,7 @@ class ExecutionRecursionDetector(object):
module = execution.get_root_value()
if module == self._infer_state.builtins_module:
if module == self._inference_state.builtins_module:
# We have control over builtins so we know they are not recursing
# like crazy. Therefore we just let them execute always, because
# they usually just help a lot with getting good results.

2
jedi/inference/star_args.py
View File

@@ -40,7 +40,7 @@ def _iter_nodes_for_param(param_name):
values = _to_callables(value, trailer)
args = TreeArguments.create_cached(
execution_value.infer_state,
execution_value.inference_state,
value=value,
argument_node=trailer.children[1],
trailer=trailer,

106
jedi/inference/syntax_tree.py
View File

@@ -23,7 +23,7 @@ from jedi.inference.value import TreeInstance
from jedi.inference.finder import NameFinder
from jedi.inference.helpers import is_string, is_literal, is_number
from jedi.inference.compiled.access import COMPARISON_OPERATORS
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.gradual.stub_value import VersionInfo
from jedi.inference.gradual import annotation
from jedi.inference.value.decorator import Decoratee
@@ -41,14 +41,14 @@ def _limit_value_infers(func):
"""
def wrapper(value, *args, **kwargs):
n = value.tree_node
infer_state = value.infer_state
inference_state = value.inference_state
try:
infer_state.inferred_element_counts[n] += 1
if infer_state.inferred_element_counts[n] > 300:
inference_state.inferred_element_counts[n] += 1
if inference_state.inferred_element_counts[n] > 300:
debug.warning('In value %s there were too many inferences.', n)
return NO_VALUES
except KeyError:
infer_state.inferred_element_counts[n] = 1
inference_state.inferred_element_counts[n] = 1
return func(value, *args, **kwargs)
return wrapper
@@ -70,7 +70,7 @@ def _py__stop_iteration_returns(generators):
@_limit_value_infers
def infer_node(value, element):
debug.dbg('infer_node %s@%s in %s', element, element.start_pos, value)
infer_state = value.infer_state
inference_state = value.inference_state
typ = element.type
if typ in ('name', 'number', 'string', 'atom', 'strings', 'keyword', 'fstring'):
return infer_atom(value, element)
@@ -91,7 +91,7 @@ def infer_node(value, element):
if trailer == '**': # has a power operation.
right = value.infer_node(children[i + 1])
value_set = _infer_comparison(
infer_state,
inference_state,
value,
value_set,
trailer,
@@ -105,7 +105,7 @@ def infer_node(value, element):
return value_set
elif typ in ('testlist_star_expr', 'testlist',):
# The implicit tuple in statements.
return ValueSet([iterable.SequenceLiteralValue(infer_state, value, element)])
return ValueSet([iterable.SequenceLiteralValue(inference_state, value, element)])
elif typ in ('not_test', 'factor'):
value_set = value.infer_node(element.children[-1])
for operator in element.children[:-1]:
@@ -122,7 +122,7 @@ def infer_node(value, element):
if element.value not in ('.', '...'):
origin = element.parent
raise AssertionError("unhandled operator %s in %s " % (repr(element.value), origin))
return ValueSet([compiled.builtin_from_name(infer_state, u'Ellipsis')])
return ValueSet([compiled.builtin_from_name(inference_state, u'Ellipsis')])
elif typ == 'dotted_name':
value_set = infer_atom(value, element.children[0])
for next_name in element.children[2::2]:
@@ -158,7 +158,7 @@ def infer_trailer(value, atom_values, trailer):
if trailer_op == '[':
trailer_op, node, _ = trailer.children
return atom_values.get_item(
infer_subscript_list(value.infer_state, value, node),
infer_subscript_list(value.inference_state, value, node),
ValueualizedNode(value, trailer)
)
else:
@@ -170,7 +170,7 @@ def infer_trailer(value, atom_values, trailer):
)
else:
assert trailer_op == '(', 'trailer_op is actually %s' % trailer_op
args = arguments.TreeArguments(value.infer_state, value, node, trailer)
args = arguments.TreeArguments(value.inference_state, value, node, trailer)
return atom_values.execute(args)
@@ -183,7 +183,7 @@ def infer_atom(value, atom):
if atom.type == 'name':
if atom.value in ('True', 'False', 'None'):
# Python 2...
return ValueSet([compiled.builtin_from_name(value.infer_state, atom.value)])
return ValueSet([compiled.builtin_from_name(value.inference_state, atom.value)])
# This is the first global lookup.
stmt = tree.search_ancestor(
@@ -207,7 +207,7 @@ def infer_atom(value, atom):
elif atom.type == 'keyword':
# For False/True/None
if atom.value in ('False', 'True', 'None'):
return ValueSet([compiled.builtin_from_name(value.infer_state, atom.value)])
return ValueSet([compiled.builtin_from_name(value.inference_state, atom.value)])
elif atom.value == 'print':
# print e.g. could be inferred like this in Python 2.7
return NO_VALUES
@@ -218,17 +218,17 @@ def infer_atom(value, atom):
assert False, 'Cannot infer the keyword %s' % atom
elif isinstance(atom, tree.Literal):
string = value.infer_state.compiled_subprocess.safe_literal_eval(atom.value)
return ValueSet([compiled.create_simple_object(value.infer_state, string)])
string = value.inference_state.compiled_subprocess.safe_literal_eval(atom.value)
return ValueSet([compiled.create_simple_object(value.inference_state, string)])
elif atom.type == 'strings':
# Will be multiple string.
value_set = infer_atom(value, atom.children[0])
for string in atom.children[1:]:
right = infer_atom(value, string)
value_set = _infer_comparison(value.infer_state, value, value_set, u'+', right)
value_set = _infer_comparison(value.inference_state, value, value_set, u'+', right)
return value_set
elif atom.type == 'fstring':
return compiled.get_string_value_set(value.infer_state)
return compiled.get_string_value_set(value.inference_state)
else:
c = atom.children
# Parentheses without commas are not tuples.
@@ -251,7 +251,7 @@ def infer_atom(value, atom):
if comp_for.type in ('comp_for', 'sync_comp_for'):
return ValueSet([iterable.comprehension_from_atom(
value.infer_state, value, atom
value.inference_state, value, atom
)])
# It's a dict/list/tuple literal.
@@ -262,19 +262,19 @@ def infer_atom(value, atom):
array_node_c = []
if c[0] == '{' and (array_node == '}' or ':' in array_node_c or
'**' in array_node_c):
new_value = iterable.DictLiteralValue(value.infer_state, value, atom)
new_value = iterable.DictLiteralValue(value.inference_state, value, atom)
else:
new_value = iterable.SequenceLiteralValue(value.infer_state, value, atom)
new_value = iterable.SequenceLiteralValue(value.inference_state, value, atom)
return ValueSet([new_value])
@_limit_value_infers
def infer_expr_stmt(value, stmt, seek_name=None):
with recursion.execution_allowed(value.infer_state, stmt) as allowed:
with recursion.execution_allowed(value.inference_state, stmt) as allowed:
# Here we allow list/set to recurse under certain conditions. To make
# it possible to resolve stuff like list(set(list(x))), this is
# necessary.
if not allowed and value.get_root_value() == value.infer_state.builtins_module:
if not allowed and value.get_root_value() == value.inference_state.builtins_module:
try:
instance = value.var_args.instance
except AttributeError:
@@ -306,7 +306,7 @@ def _infer_expr_stmt(value, stmt, seek_name=None):
if seek_name:
c_node = ValueualizedName(value, seek_name)
value_set = check_tuple_assignments(value.infer_state, c_node, value_set)
value_set = check_tuple_assignments(value.inference_state, c_node, value_set)
first_operator = next(stmt.yield_operators(), None)
if first_operator not in ('=', None) and first_operator.type == 'operator':
@@ -331,10 +331,10 @@ def _infer_expr_stmt(value, stmt, seek_name=None):
dct = {for_stmt.children[1].value: lazy_value.infer()}
with helpers.predefine_names(value, for_stmt, dct):
t = value.infer_node(rhs)
left = _infer_comparison(value.infer_state, value, left, operator, t)
left = _infer_comparison(value.inference_state, value, left, operator, t)
value_set = left
else:
value_set = _infer_comparison(value.infer_state, value, left, operator, value_set)
value_set = _infer_comparison(value.inference_state, value, left, operator, value_set)
debug.dbg('infer_expr_stmt result %s', value_set)
return value_set
@@ -358,7 +358,7 @@ def infer_or_test(value, or_test):
types = value.infer_node(right)
# Otherwise continue, because of uncertainty.
else:
types = _infer_comparison(value.infer_state, value, types, operator,
types = _infer_comparison(value.inference_state, value, types, operator,
value.infer_node(right))
debug.dbg('infer_or_test types %s', types)
return types
@@ -377,12 +377,12 @@ def infer_factor(value_set, operator):
b = value.py__bool__()
if b is None: # Uncertainty.
return
yield compiled.create_simple_object(value.infer_state, not b)
yield compiled.create_simple_object(value.inference_state, not b)
else:
yield value
def _literals_to_types(infer_state, result):
def _literals_to_types(inference_state, result):
# Changes literals ('a', 1, 1.0, etc) to its type instances (str(),
# int(), float(), etc).
new_result = NO_VALUES
@@ -390,27 +390,27 @@ def _literals_to_types(infer_state, result):
if is_literal(typ):
# Literals are only valid as long as the operations are
# correct. Otherwise add a value-free instance.
cls = compiled.builtin_from_name(infer_state, typ.name.string_name)
cls = compiled.builtin_from_name(inference_state, typ.name.string_name)
new_result |= cls.execute_with_values()
else:
new_result |= ValueSet([typ])
return new_result
def _infer_comparison(infer_state, value, left_values, operator, right_values):
def _infer_comparison(inference_state, value, left_values, operator, right_values):
if not left_values or not right_values:
# illegal slices e.g. cause left/right_result to be None
result = (left_values or NO_VALUES) | (right_values or NO_VALUES)
return _literals_to_types(infer_state, result)
return _literals_to_types(inference_state, result)
else:
# I don't think there's a reasonable chance that a string
# operation is still correct, once we pass something like six
# objects.
if len(left_values) * len(right_values) > 6:
return _literals_to_types(infer_state, left_values | right_values)
return _literals_to_types(inference_state, left_values | right_values)
else:
return ValueSet.from_sets(
_infer_comparison_part(infer_state, value, left, operator, right)
_infer_comparison_part(inference_state, value, left, operator, right)
for left in left_values
for right in right_values
)
@@ -440,8 +440,8 @@ def _is_list(value):
return isinstance(value, iterable.Sequence) and value.array_type == 'list'
def _bool_to_value(infer_state, bool_):
return compiled.builtin_from_name(infer_state, force_unicode(str(bool_)))
def _bool_to_value(inference_state, bool_):
return compiled.builtin_from_name(inference_state, force_unicode(str(bool_)))
def _get_tuple_ints(value):
@@ -461,7 +461,7 @@ def _get_tuple_ints(value):
return numbers
def _infer_comparison_part(infer_state, value, left, operator, right):
def _infer_comparison_part(inference_state, value, left, operator, right):
l_is_num = is_number(left)
r_is_num = is_number(right)
if isinstance(operator, unicode):
@@ -479,7 +479,7 @@ def _infer_comparison_part(infer_state, value, left, operator, right):
if l_is_num and r_is_num or is_string(left) and is_string(right):
return ValueSet([left.execute_operation(right, str_operator)])
elif _is_tuple(left) and _is_tuple(right) or _is_list(left) and _is_list(right):
return ValueSet([iterable.MergedArray(infer_state, (left, right))])
return ValueSet([iterable.MergedArray(inference_state, (left, right))])
elif str_operator == '-':
if l_is_num and r_is_num:
return ValueSet([left.execute_operation(right, str_operator)])
@@ -499,18 +499,18 @@ def _infer_comparison_part(infer_state, value, left, operator, right):
if str_operator in ('is', '!=', '==', 'is not'):
operation = COMPARISON_OPERATORS[str_operator]
bool_ = operation(left, right)
return ValueSet([_bool_to_value(infer_state, bool_)])
return ValueSet([_bool_to_value(inference_state, bool_)])
if isinstance(left, VersionInfo):
version_info = _get_tuple_ints(right)
if version_info is not None:
bool_result = compiled.access.COMPARISON_OPERATORS[operator](
infer_state.environment.version_info,
inference_state.environment.version_info,
tuple(version_info)
)
return ValueSet([_bool_to_value(infer_state, bool_result)])
return ValueSet([_bool_to_value(inference_state, bool_result)])
return ValueSet([_bool_to_value(infer_state, True), _bool_to_value(infer_state, False)])
return ValueSet([_bool_to_value(inference_state, True), _bool_to_value(inference_state, False)])
elif str_operator == 'in':
return NO_VALUES
@@ -531,7 +531,7 @@ def _infer_comparison_part(infer_state, value, left, operator, right):
return result
def _remove_statements(infer_state, value, stmt, name):
def _remove_statements(inference_state, value, stmt, name):
"""
This is the part where statements are being stripped.
@@ -547,7 +547,7 @@ def _remove_statements(infer_state, value, stmt, name):
@plugin_manager.decorate()
def tree_name_to_values(infer_state, value, tree_name):
def tree_name_to_values(inference_state, value, tree_name):
value_set = NO_VALUES
module_node = value.get_root_value().tree_node
# First check for annotations, like: `foo: int = 3`
@@ -570,15 +570,15 @@ def tree_name_to_values(infer_state, value, tree_name):
if node is None:
node = tree_name.parent
if node.type == 'global_stmt':
value = infer_state.create_value(value, tree_name)
finder = NameFinder(infer_state, value, value, tree_name.value)
value = inference_state.create_value(value, tree_name)
finder = NameFinder(inference_state, value, value, tree_name.value)
filters = finder.get_global_filters()
# For global_stmt lookups, we only need the first possible scope,
# which means the function itself.
filters = [next(filters)]
return finder.find(filters, attribute_lookup=False)
elif node.type not in ('import_from', 'import_name'):
value = infer_state.create_value(value, tree_name)
value = inference_state.create_value(value, tree_name)
return infer_atom(value, tree_name)
typ = node.type
@@ -602,9 +602,9 @@ def tree_name_to_values(infer_state, value, tree_name):
is_async=node.parent.type == 'async_stmt',
)
c_node = ValueualizedName(value, tree_name)
types = check_tuple_assignments(infer_state, c_node, for_types)
types = check_tuple_assignments(inference_state, c_node, for_types)
elif typ == 'expr_stmt':
types = _remove_statements(infer_state, value, node, tree_name)
types = _remove_statements(inference_state, value, node, tree_name)
elif typ == 'with_stmt':
value_managers = value.infer_node(node.get_test_node_from_name(tree_name))
enter_methods = value_managers.py__getattribute__(u'__enter__')
@@ -628,7 +628,7 @@ def tree_name_to_values(infer_state, value, tree_name):
# We don't want to have functions/classes that are created by the same
# tree_node.
@infer_state_method_cache()
@inference_state_method_cache()
def _apply_decorators(value, node):
"""
Returns the function, that should to be executed in the end.
@@ -636,7 +636,7 @@ def _apply_decorators(value, node):
"""
if node.type == 'classdef':
decoratee_value = ClassValue(
value.infer_state,
value.inference_state,
parent_context=value,
tree_node=node
)
@@ -674,7 +674,7 @@ def _apply_decorators(value, node):
return values
def check_tuple_assignments(infer_state, valueualized_name, value_set):
def check_tuple_assignments(inference_state, valueualized_name, value_set):
"""
Checks if tuples are assigned.
"""
@@ -698,7 +698,7 @@ def check_tuple_assignments(infer_state, valueualized_name, value_set):
return value_set
def infer_subscript_list(infer_state, value, index):
def infer_subscript_list(inference_state, value, index):
"""
Handles slices in subscript nodes.
"""
@@ -724,7 +724,7 @@ def infer_subscript_list(infer_state, value, index):
return ValueSet([iterable.Slice(value, *result)])
elif index.type == 'subscriptlist':
return ValueSet([iterable.SequenceLiteralValue(infer_state, value, index)])
return ValueSet([iterable.SequenceLiteralValue(inference_state, value, index)])
# No slices
return value.infer_node(index)

16
jedi/inference/sys_path.py
View File

@@ -1,7 +1,7 @@
import os
from jedi._compatibility import unicode, force_unicode, all_suffixes
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.base_value import ValueualizedNode
from jedi.inference.helpers import is_string
from jedi.common.utils import traverse_parents
@@ -92,7 +92,7 @@ def _paths_from_list_modifications(module_value, trailer1, trailer2):
yield abs_path
@infer_state_method_cache(default=[])
@inference_state_method_cache(default=[])
def check_sys_path_modifications(module_value):
"""
Detect sys.path modifications within module.
@@ -130,20 +130,20 @@ def check_sys_path_modifications(module_value):
return added
def discover_buildout_paths(infer_state, script_path):
def discover_buildout_paths(inference_state, script_path):
buildout_script_paths = set()
for buildout_script_path in _get_buildout_script_paths(script_path):
for path in _get_paths_from_buildout_script(infer_state, buildout_script_path):
for path in _get_paths_from_buildout_script(inference_state, buildout_script_path):
buildout_script_paths.add(path)
return buildout_script_paths
def _get_paths_from_buildout_script(infer_state, buildout_script_path):
def _get_paths_from_buildout_script(inference_state, buildout_script_path):
file_io = FileIO(buildout_script_path)
try:
module_node = infer_state.parse(
module_node = inference_state.parse(
file_io=file_io,
cache=True,
cache_path=settings.cache_directory
@@ -154,9 +154,9 @@ def _get_paths_from_buildout_script(infer_state, buildout_script_path):
from jedi.inference.value import ModuleValue
module = ModuleValue(
infer_state, module_node, file_io,
inference_state, module_node, file_io,
string_names=None,
code_lines=get_cached_code_lines(infer_state.grammar, buildout_script_path),
code_lines=get_cached_code_lines(inference_state.grammar, buildout_script_path),
)
for path in check_sys_path_modifications(module):
yield path

2
jedi/inference/usages.py
View File

@@ -41,7 +41,7 @@ def usages(module_value, tree_name):
modules = set(m for m in modules if m.is_module() and not m.is_compiled())
non_matching_usage_maps = {}
for m in imports.get_modules_containing_name(module_value.infer_state, modules, search_name):
for m in imports.get_modules_containing_name(module_value.inference_state, modules, search_name):
for name_leaf in m.tree_node.get_used_names().get(search_name, []):
new = _find_names(m, name_leaf)
if any(tree_name in found_names for tree_name in new):

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

@@ -2,7 +2,7 @@ from parso.python import tree
from jedi._compatibility import use_metaclass
from jedi import debug
from jedi.inference.cache import infer_state_method_cache, CachedMetaClass
from jedi.inference.cache import inference_state_method_cache, CachedMetaClass
from jedi.inference import compiled
from jedi.inference import recursion
from jedi.inference import docstrings
@@ -97,7 +97,7 @@ class FunctionMixin(object):
if arguments is None:
arguments = AnonymousArguments()
return FunctionExecutionValue(self.infer_state, self.parent_context, self, arguments)
return FunctionExecutionValue(self.inference_state, self.parent_context, self, arguments)
def get_signatures(self):
return [TreeSignature(f) for f in self.get_signature_functions()]
@@ -112,14 +112,14 @@ class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndCla
def create(tree_node):
if value.is_class():
return MethodValue(
value.infer_state,
value.inference_state,
value,
parent_context=parent_context,
tree_node=tree_node
)
else:
return cls(
value.infer_state,
value.inference_state,
parent_context=parent_context,
tree_node=tree_node
)
@@ -140,7 +140,7 @@ class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndCla
return function
def py__class__(self):
c, = values_from_qualified_names(self.infer_state, u'types', u'FunctionType')
c, = values_from_qualified_names(self.inference_state, u'types', u'FunctionType')
return c
def get_default_param_value(self):
@@ -151,8 +151,8 @@ class FunctionValue(use_metaclass(CachedMetaClass, FunctionMixin, FunctionAndCla
class MethodValue(FunctionValue):
def __init__(self, infer_state, class_value, *args, **kwargs):
super(MethodValue, self).__init__(infer_state, *args, **kwargs)
def __init__(self, inference_state, class_value, *args, **kwargs):
super(MethodValue, self).__init__(inference_state, *args, **kwargs)
self.class_value = class_value
def get_default_param_value(self):
@@ -170,16 +170,16 @@ class MethodValue(FunctionValue):
class FunctionExecutionValue(TreeValue):
function_execution_filter = FunctionExecutionFilter
def __init__(self, infer_state, parent_context, function_value, var_args):
def __init__(self, inference_state, parent_context, function_value, var_args):
super(FunctionExecutionValue, self).__init__(
infer_state,
inference_state,
parent_context,
function_value.tree_node,
)
self.function_value = function_value
self.var_args = var_args
@infer_state_method_cache(default=NO_VALUES)
@inference_state_method_cache(default=NO_VALUES)
@recursion.execution_recursion_decorator()
def get_return_values(self, check_yields=False):
funcdef = self.tree_node
@@ -188,7 +188,7 @@ class FunctionExecutionValue(TreeValue):
if check_yields:
value_set = NO_VALUES
returns = get_yield_exprs(self.infer_state, funcdef)
returns = get_yield_exprs(self.inference_state, funcdef)
else:
returns = funcdef.iter_return_stmts()
from jedi.inference.gradual.annotation import infer_return_types
@@ -213,7 +213,7 @@ class FunctionExecutionValue(TreeValue):
try:
children = r.children
except AttributeError:
ctx = compiled.builtin_from_name(self.infer_state, u'None')
ctx = compiled.builtin_from_name(self.inference_state, u'None')
value_set |= ValueSet([ctx])
else:
value_set |= self.infer_node(children[1])
@@ -225,7 +225,7 @@ class FunctionExecutionValue(TreeValue):
def _get_yield_lazy_value(self, yield_expr):
if yield_expr.type == 'keyword':
# `yield` just yields None.
ctx = compiled.builtin_from_name(self.infer_state, u'None')
ctx = compiled.builtin_from_name(self.inference_state, u'None')
yield LazyKnownValue(ctx)
return
@@ -242,7 +242,7 @@ class FunctionExecutionValue(TreeValue):
# TODO: if is_async, wrap yield statements in Awaitable/async_generator_asend
for_parents = [(y, tree.search_ancestor(y, 'for_stmt', 'funcdef',
'while_stmt', 'if_stmt'))
for y in get_yield_exprs(self.infer_state, self.tree_node)]
for y in get_yield_exprs(self.inference_state, self.tree_node)]
# Calculate if the yields are placed within the same for loop.
yields_order = []
@@ -297,7 +297,7 @@ class FunctionExecutionValue(TreeValue):
until_position=until_position,
origin_scope=origin_scope)
@infer_state_method_cache()
@inference_state_method_cache()
def get_executed_params_and_issues(self):
return self.var_args.get_executed_params_and_issues(self)
@@ -322,16 +322,16 @@ class FunctionExecutionValue(TreeValue):
"""
Created to be used by inheritance.
"""
infer_state = self.infer_state
inference_state = self.inference_state
is_coroutine = self.tree_node.parent.type in ('async_stmt', 'async_funcdef')
is_generator = bool(get_yield_exprs(infer_state, self.tree_node))
is_generator = bool(get_yield_exprs(inference_state, self.tree_node))
from jedi.inference.gradual.typing import GenericClass
if is_coroutine:
if is_generator:
if infer_state.environment.version_info < (3, 6):
if inference_state.environment.version_info < (3, 6):
return NO_VALUES
async_generator_classes = infer_state.typing_module \
async_generator_classes = inference_state.typing_module \
.py__getattribute__('AsyncGenerator')
yield_values = self.merge_yield_values(is_async=True)
@@ -343,9 +343,9 @@ class FunctionExecutionValue(TreeValue):
for c in async_generator_classes
).execute_annotation()
else:
if infer_state.environment.version_info < (3, 5):
if inference_state.environment.version_info < (3, 5):
return NO_VALUES
async_classes = infer_state.typing_module.py__getattribute__('Coroutine')
async_classes = inference_state.typing_module.py__getattribute__('Coroutine')
return_values = self.get_return_values()
# Only the first generic is relevant.
generics = (return_values.py__class__(), NO_VALUES, NO_VALUES)
@@ -354,7 +354,7 @@ class FunctionExecutionValue(TreeValue):
).execute_annotation()
else:
if is_generator:
return ValueSet([iterable.Generator(infer_state, self)])
return ValueSet([iterable.Generator(inference_state, self)])
else:
return self.get_return_values()
@@ -379,7 +379,7 @@ class OverloadedFunctionValue(FunctionMixin, ValueWrapper):
if matched:
return value_set
if self.infer_state.is_analysis:
if self.inference_state.is_analysis:
# In this case we want precision.
return NO_VALUES
return ValueSet.from_sets(fe.infer() for fe in function_executions)
@@ -411,7 +411,7 @@ def _find_overload_functions(value, tree_node):
while True:
filter = ParserTreeFilter(
value.infer_state,
value.inference_state,
value,
until_position=tree_node.start_pos
)

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

@@ -10,7 +10,7 @@ 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.cache import inference_state_method_cache
from jedi.inference.arguments import AnonymousArguments, \
ValuesArguments, TreeArgumentsWrapper
from jedi.inference.value.function import \
@@ -50,7 +50,7 @@ class AnonymousInstanceArguments(AnonymousArguments):
# executions of this function, we have all the params already.
return [self_param], []
executed_params = list(search_params(
execution_value.infer_state,
execution_value.inference_state,
execution_value,
execution_value.tree_node
))
@@ -61,8 +61,8 @@ class AnonymousInstanceArguments(AnonymousArguments):
class AbstractInstanceValue(Value):
api_type = u'instance'
def __init__(self, infer_state, parent_context, class_value, var_args):
super(AbstractInstanceValue, self).__init__(infer_state, parent_context)
def __init__(self, inference_state, parent_context, class_value, var_args):
super(AbstractInstanceValue, self).__init__(inference_state, parent_context)
# Generated instances are classes that are just generated by self
# (No var_args) used.
self.class_value = class_value
@@ -117,7 +117,7 @@ class AbstractInstanceValue(Value):
names = self.get_function_slot_names(u'__get__')
if names:
if obj is None:
obj = compiled.builtin_from_name(self.infer_state, u'None')
obj = compiled.builtin_from_name(self.inference_state, u'None')
return self.execute_function_slots(names, obj, class_value)
else:
return ValueSet([self])
@@ -168,7 +168,7 @@ class AbstractInstanceValue(Value):
for generator in self.execute_function_slots(iter_slot_names):
if generator.is_instance() and not generator.is_compiled():
# `__next__` logic.
if self.infer_state.environment.version_info.major == 2:
if self.inference_state.environment.version_info.major == 2:
name = u'next'
else:
name = u'__next__'
@@ -199,7 +199,7 @@ class AbstractInstanceValue(Value):
bound_method = BoundMethod(self, function)
yield bound_method.get_function_execution(self.var_args)
@infer_state_method_cache()
@inference_state_method_cache()
def create_instance_value(self, class_value, node):
if node.parent.type in ('funcdef', 'classdef'):
node = node.parent
@@ -219,7 +219,7 @@ class AbstractInstanceValue(Value):
else:
return bound_method.get_function_execution()
elif scope.type == 'classdef':
class_value = ClassValue(self.infer_state, parent_context, scope)
class_value = ClassValue(self.inference_state, parent_context, scope)
return class_value
elif scope.type in ('comp_for', 'sync_comp_for'):
# Comprehensions currently don't have a special scope in Jedi.
@@ -238,9 +238,9 @@ class AbstractInstanceValue(Value):
class CompiledInstance(AbstractInstanceValue):
def __init__(self, infer_state, parent_context, class_value, var_args):
def __init__(self, inference_state, parent_context, class_value, var_args):
self._original_var_args = var_args
super(CompiledInstance, self).__init__(infer_state, parent_context, class_value, var_args)
super(CompiledInstance, self).__init__(inference_state, parent_context, class_value, var_args)
@property
def name(self):
@@ -258,16 +258,16 @@ class CompiledInstance(AbstractInstanceValue):
class TreeInstance(AbstractInstanceValue):
def __init__(self, infer_state, parent_context, class_value, var_args):
def __init__(self, inference_state, parent_context, 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__.
if class_value.py__name__() in ['list', 'set'] \
and parent_context.get_root_value() == infer_state.builtins_module:
and parent_context.get_root_value() == inference_state.builtins_module:
# compare the module path with the builtin name.
if settings.dynamic_array_additions:
var_args = iterable.get_dynamic_array_instance(self, var_args)
super(TreeInstance, self).__init__(infer_state, parent_context,
super(TreeInstance, self).__init__(inference_state, parent_context,
class_value, var_args)
self.tree_node = class_value.tree_node
@@ -277,7 +277,7 @@ class TreeInstance(AbstractInstanceValue):
# This can recurse, if the initialization of the class includes a reference
# to itself.
@infer_state_method_cache(default=None)
@inference_state_method_cache(default=None)
def _get_annotated_class_object(self):
from jedi.inference.gradual.annotation import py__annotations__, \
infer_type_vars_for_execution
@@ -313,9 +313,9 @@ class TreeInstance(AbstractInstanceValue):
class AnonymousInstance(TreeInstance):
def __init__(self, infer_state, parent_context, class_value):
def __init__(self, inference_state, parent_context, class_value):
super(AnonymousInstance, self).__init__(
infer_state,
inference_state,
parent_context,
class_value,
var_args=AnonymousInstanceArguments(self),
@@ -327,9 +327,9 @@ class AnonymousInstance(TreeInstance):
class CompiledInstanceName(compiled.CompiledName):
def __init__(self, infer_state, instance, klass, name):
def __init__(self, inference_state, instance, klass, name):
super(CompiledInstanceName, self).__init__(
infer_state,
inference_state,
klass.parent_context,
name.string_name
)
@@ -361,7 +361,7 @@ class CompiledInstanceClassFilter(AbstractFilter):
def _convert(self, names):
klass = self._class_filter.compiled_object
return [
CompiledInstanceName(self._instance.infer_state, self._instance, klass, n)
CompiledInstanceName(self._instance.inference_state, self._instance, klass, n)
for n in names
]
@@ -375,7 +375,7 @@ class BoundMethod(FunctionMixin, ValueWrapper):
return True
def py__class__(self):
c, = values_from_qualified_names(self.infer_state, u'types', u'MethodType')
c, = values_from_qualified_names(self.inference_state, u'types', u'MethodType')
return c
def _get_arguments(self, arguments):

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

@@ -34,7 +34,7 @@ from jedi.inference.helpers import get_int_or_none, is_string, \
predefine_names, infer_call_of_leaf, reraise_getitem_errors, \
SimpleGetItemNotFound
from jedi.inference.utils import safe_property, to_list
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.filters import ParserTreeFilter, LazyAttributeOverwrite, \
publish_method
from jedi.inference.base_value import ValueSet, Value, NO_VALUES, \
@@ -44,7 +44,7 @@ from jedi.parser_utils import get_sync_comp_fors
class IterableMixin(object):
def py__stop_iteration_returns(self):
return ValueSet([compiled.builtin_from_name(self.infer_state, u'None')])
return ValueSet([compiled.builtin_from_name(self.inference_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
@@ -66,7 +66,7 @@ class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
array_type = None
def _get_wrapped_value(self):
generator, = self.infer_state.typing_module \
generator, = self.inference_state.typing_module \
.py__getattribute__('Generator') \
.execute_annotation()
return generator
@@ -88,7 +88,7 @@ class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())
def py__stop_iteration_returns(self):
return ValueSet([compiled.builtin_from_name(self.infer_state, u'None')])
return ValueSet([compiled.builtin_from_name(self.inference_state, u'None')])
@property
def name(self):
@@ -97,8 +97,8 @@ class GeneratorBase(LazyAttributeOverwrite, IterableMixin):
class Generator(GeneratorBase):
"""Handling of `yield` functions."""
def __init__(self, infer_state, func_execution_value):
super(Generator, self).__init__(infer_state)
def __init__(self, inference_state, func_execution_value):
super(Generator, self).__init__(inference_state)
self._func_execution_value = func_execution_value
def py__iter__(self, valueualized_node=None):
@@ -114,13 +114,13 @@ class Generator(GeneratorBase):
class CompForValue(TreeValue):
@classmethod
def from_comp_for(cls, parent_context, comp_for):
return cls(parent_context.infer_state, parent_context, comp_for)
return cls(parent_context.inference_state, parent_context, comp_for)
def get_filters(self, search_global=False, until_position=None, origin_scope=None):
yield ParserTreeFilter(self)
def comprehension_from_atom(infer_state, value, atom):
def comprehension_from_atom(inference_state, value, atom):
bracket = atom.children[0]
test_list_comp = atom.children[1]
@@ -131,7 +131,7 @@ def comprehension_from_atom(infer_state, value, atom):
sync_comp_for = sync_comp_for.children[1]
return DictComprehension(
infer_state,
inference_state,
value,
sync_comp_for_node=sync_comp_for,
key_node=test_list_comp.children[0],
@@ -149,7 +149,7 @@ def comprehension_from_atom(infer_state, value, atom):
sync_comp_for = sync_comp_for.children[1]
return cls(
infer_state,
inference_state,
defining_value=value,
sync_comp_for_node=sync_comp_for,
entry_node=test_list_comp.children[0],
@@ -157,7 +157,7 @@ def comprehension_from_atom(infer_state, value, atom):
class ComprehensionMixin(object):
@infer_state_method_cache()
@inference_state_method_cache()
def _get_comp_for_value(self, parent_context, comp_for):
return CompForValue.from_comp_for(parent_context, comp_for)
@@ -192,7 +192,7 @@ class ComprehensionMixin(object):
else:
yield iterated
@infer_state_method_cache(default=[])
@inference_state_method_cache(default=[])
@to_list
def _iterate(self):
comp_fors = tuple(get_sync_comp_fors(self._sync_comp_for_node))
@@ -224,7 +224,7 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
def _get_wrapped_value(self):
from jedi.inference.gradual.typing import GenericClass
klass = compiled.builtin_from_name(self.infer_state, self.array_type)
klass = compiled.builtin_from_name(self.inference_state, self.array_type)
c, = GenericClass(klass, self._get_generics()).execute_annotation()
return c
@@ -232,11 +232,11 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
return None # We don't know the length, because of appends.
def py__class__(self):
return compiled.builtin_from_name(self.infer_state, self.array_type)
return compiled.builtin_from_name(self.inference_state, self.array_type)
@safe_property
def parent(self):
return self.infer_state.builtins_module
return self.inference_state.builtins_module
def py__getitem__(self, index_value_set, valueualized_node):
if self.array_type == 'dict':
@@ -245,9 +245,9 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
class _BaseComprehension(ComprehensionMixin):
def __init__(self, infer_state, defining_value, sync_comp_for_node, entry_node):
def __init__(self, inference_state, defining_value, sync_comp_for_node, entry_node):
assert sync_comp_for_node.type == 'sync_comp_for'
super(_BaseComprehension, self).__init__(infer_state)
super(_BaseComprehension, self).__init__(inference_state)
self._defining_value = defining_value
self._sync_comp_for_node = sync_comp_for_node
self._entry_node = entry_node
@@ -277,9 +277,9 @@ class GeneratorComprehension(_BaseComprehension, GeneratorBase):
class DictComprehension(ComprehensionMixin, Sequence):
array_type = u'dict'
def __init__(self, infer_state, defining_value, sync_comp_for_node, key_node, value_node):
def __init__(self, inference_state, defining_value, sync_comp_for_node, key_node, value_node):
assert sync_comp_for_node.type == 'sync_comp_for'
super(DictComprehension, self).__init__(infer_state)
super(DictComprehension, self).__init__(inference_state)
self._defining_value = defining_value
self._sync_comp_for_node = sync_comp_for_node
self._entry_node = key_node
@@ -308,14 +308,14 @@ class DictComprehension(ComprehensionMixin, Sequence):
@publish_method('values')
def _imitate_values(self):
lazy_value = LazyKnownValues(self._dict_values())
return ValueSet([FakeSequence(self.infer_state, u'list', [lazy_value])])
return ValueSet([FakeSequence(self.inference_state, u'list', [lazy_value])])
@publish_method('items')
def _imitate_items(self):
lazy_values = [
LazyKnownValue(
FakeSequence(
self.infer_state,
self.inference_state,
u'tuple',
[LazyKnownValues(key),
LazyKnownValues(value)]
@@ -324,7 +324,7 @@ class DictComprehension(ComprehensionMixin, Sequence):
for key, value in self._iterate()
]
return ValueSet([FakeSequence(self.infer_state, u'list', lazy_values)])
return ValueSet([FakeSequence(self.inference_state, u'list', lazy_values)])
def get_mapping_item_values(self):
return self._dict_keys(), self._dict_values()
@@ -341,8 +341,8 @@ class SequenceLiteralValue(Sequence):
'[': u'list',
'{': u'set'}
def __init__(self, infer_state, defining_value, atom):
super(SequenceLiteralValue, self).__init__(infer_state)
def __init__(self, inference_state, defining_value, atom):
super(SequenceLiteralValue, self).__init__(inference_state)
self.atom = atom
self._defining_value = defining_value
@@ -355,7 +355,7 @@ class SequenceLiteralValue(Sequence):
def py__simple_getitem__(self, index):
"""Here the index is an int/str. Raises IndexError/KeyError."""
if self.array_type == u'dict':
compiled_obj_index = compiled.create_simple_object(self.infer_state, index)
compiled_obj_index = compiled.create_simple_object(self.inference_state, index)
for key, value in self.get_tree_entries():
for k in self._defining_value.infer_node(key):
try:
@@ -471,27 +471,27 @@ class SequenceLiteralValue(Sequence):
class DictLiteralValue(_DictMixin, SequenceLiteralValue):
array_type = u'dict'
def __init__(self, infer_state, defining_value, atom):
super(SequenceLiteralValue, self).__init__(infer_state)
def __init__(self, inference_state, defining_value, atom):
super(SequenceLiteralValue, self).__init__(inference_state)
self._defining_value = defining_value
self.atom = atom
@publish_method('values')
def _imitate_values(self):
lazy_value = LazyKnownValues(self._dict_values())
return ValueSet([FakeSequence(self.infer_state, u'list', [lazy_value])])
return ValueSet([FakeSequence(self.inference_state, u'list', [lazy_value])])
@publish_method('items')
def _imitate_items(self):
lazy_values = [
LazyKnownValue(FakeSequence(
self.infer_state, u'tuple',
self.inference_state, u'tuple',
(LazyTreeValue(self._defining_value, key_node),
LazyTreeValue(self._defining_value, value_node))
)) for key_node, value_node in self.get_tree_entries()
]
return ValueSet([FakeSequence(self.infer_state, u'list', lazy_values)])
return ValueSet([FakeSequence(self.inference_state, u'list', lazy_values)])
def _dict_keys(self):
return ValueSet.from_sets(
@@ -504,19 +504,19 @@ class DictLiteralValue(_DictMixin, SequenceLiteralValue):
class _FakeArray(SequenceLiteralValue):
def __init__(self, infer_state, container, type):
super(SequenceLiteralValue, self).__init__(infer_state)
def __init__(self, inference_state, container, type):
super(SequenceLiteralValue, self).__init__(inference_state)
self.array_type = type
self.atom = container
# TODO is this class really needed?
class FakeSequence(_FakeArray):
def __init__(self, infer_state, array_type, lazy_value_list):
def __init__(self, inference_state, array_type, lazy_value_list):
"""
type should be one of "tuple", "list"
"""
super(FakeSequence, self).__init__(infer_state, None, array_type)
super(FakeSequence, self).__init__(inference_state, None, array_type)
self._lazy_value_list = lazy_value_list
def py__simple_getitem__(self, index):
@@ -538,16 +538,16 @@ class FakeSequence(_FakeArray):
class FakeDict(_DictMixin, _FakeArray):
def __init__(self, infer_state, dct):
super(FakeDict, self).__init__(infer_state, dct, u'dict')
def __init__(self, inference_state, dct):
super(FakeDict, self).__init__(inference_state, dct, u'dict')
self._dct = dct
def py__iter__(self, valueualized_node=None):
for key in self._dct:
yield LazyKnownValue(compiled.create_simple_object(self.infer_state, key))
yield LazyKnownValue(compiled.create_simple_object(self.inference_state, key))
def py__simple_getitem__(self, index):
if is_py3 and self.infer_state.environment.version_info.major == 2:
if is_py3 and self.inference_state.environment.version_info.major == 2:
# In Python 2 bytes and unicode compare.
if isinstance(index, bytes):
index_unicode = force_unicode(index)
@@ -569,7 +569,7 @@ class FakeDict(_DictMixin, _FakeArray):
@publish_method('values')
def _values(self):
return ValueSet([FakeSequence(
self.infer_state, u'tuple',
self.inference_state, u'tuple',
[LazyKnownValues(self._dict_values())]
)])
@@ -587,8 +587,8 @@ class FakeDict(_DictMixin, _FakeArray):
class MergedArray(_FakeArray):
def __init__(self, infer_state, arrays):
super(MergedArray, self).__init__(infer_state, arrays, arrays[-1].array_type)
def __init__(self, inference_state, arrays):
super(MergedArray, self).__init__(inference_state, arrays, arrays[-1].array_type)
self._arrays = arrays
def py__iter__(self, valueualized_node=None):
@@ -657,7 +657,7 @@ def check_array_additions(value, sequence):
return _check_array_additions(value, sequence)
@infer_state_method_cache(default=NO_VALUES)
@inference_state_method_cache(default=NO_VALUES)
@debug.increase_indent
def _check_array_additions(value, sequence):
"""
@@ -675,7 +675,7 @@ def _check_array_additions(value, sequence):
return NO_VALUES
def find_additions(value, arglist, add_name):
params = list(arguments.TreeArguments(value.infer_state, value, arglist).unpack())
params = list(arguments.TreeArguments(value.inference_state, value, arglist).unpack())
result = set()
if add_name in ['insert']:
params = params[1:]
@@ -719,7 +719,7 @@ def _check_array_additions(value, sequence):
random_value = value.create_value(name)
with recursion.execution_allowed(value.infer_state, power) as allowed:
with recursion.execution_allowed(value.inference_state, power) as allowed:
if allowed:
found = infer_call_of_leaf(
random_value,
@@ -758,7 +758,7 @@ class _ArrayInstance(HelperValueMixin):
self.var_args = var_args
def py__class__(self):
tuple_, = self.instance.infer_state.builtins_module.py__getattribute__('tuple')
tuple_, = self.instance.inference_state.builtins_module.py__getattribute__('tuple')
return tuple_
def py__iter__(self, valueualized_node=None):
@@ -792,7 +792,7 @@ class Slice(object):
def __getattr__(self, name):
if self._slice_object is None:
value = compiled.builtin_from_name(self._value.infer_state, 'slice')
value = compiled.builtin_from_name(self._value.inference_state, 'slice')
self._slice_object, = value.execute_with_values()
return getattr(self._slice_object, name)

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

@@ -39,8 +39,8 @@ py__doc__() Returns the docstring for a value.
from jedi import debug
from jedi._compatibility import use_metaclass
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.cache import inference_state_method_cache, CachedMetaClass, \
inference_state_method_generator_cache
from jedi.inference import compiled
from jedi.inference.lazy_value import LazyKnownValues
from jedi.inference.filters import ParserTreeFilter
@@ -73,7 +73,7 @@ class ClassName(TreeNameDefinition):
# We're using a different value to infer, so we cannot call super().
from jedi.inference.syntax_tree import tree_name_to_values
inferred = tree_name_to_values(
self.parent_context.infer_state, self._name_value, self.tree_name)
self.parent_context.inference_state, self._name_value, self.tree_name)
for result_value in inferred:
if self._apply_decorators:
@@ -141,10 +141,10 @@ class ClassMixin(object):
from jedi.inference.value import TreeInstance
if arguments is None:
arguments = ValuesArguments([])
return ValueSet([TreeInstance(self.infer_state, self.parent_context, self, arguments)])
return ValueSet([TreeInstance(self.inference_state, self.parent_context, self, arguments)])
def py__class__(self):
return compiled.builtin_from_name(self.infer_state, u'type')
return compiled.builtin_from_name(self.inference_state, u'type')
@property
def name(self):
@@ -159,7 +159,7 @@ class ClassMixin(object):
return list(value_.get_param_names())[1:]
return []
@infer_state_method_generator_cache()
@inference_state_method_generator_cache()
def py__mro__(self):
mro = [self]
yield self
@@ -214,7 +214,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')
type_ = builtin_from_name(self.inference_state, u'type')
assert isinstance(type_, ClassValue)
if type_ != self:
for instance in type_.py__call__():
@@ -239,7 +239,7 @@ class ClassMixin(object):
class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase)):
api_type = u'class'
@infer_state_method_cache()
@inference_state_method_cache()
def list_type_vars(self):
found = []
arglist = self.tree_node.get_super_arglist()
@@ -261,10 +261,10 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
arglist = self.tree_node.get_super_arglist()
if arglist:
from jedi.inference import arguments
return arguments.TreeArguments(self.infer_state, self.parent_context, arglist)
return arguments.TreeArguments(self.inference_state, self.parent_context, arglist)
return None
@infer_state_method_cache(default=())
@inference_state_method_cache(default=())
def py__bases__(self):
args = self._get_bases_arguments()
if args is not None:
@@ -273,10 +273,10 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
return lst
if self.py__name__() == 'object' \
and self.parent_context == self.infer_state.builtins_module:
and self.parent_context == self.inference_state.builtins_module:
return []
return [LazyKnownValues(
self.infer_state.builtins_module.py__getattribute__('object')
self.inference_state.builtins_module.py__getattribute__('object')
)]
def py__getitem__(self, index_value_set, valueualized_node):
@@ -320,7 +320,7 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
debug.dbg('Unprocessed metaclass %s', metaclass)
return []
@infer_state_method_cache(default=NO_VALUES)
@inference_state_method_cache(default=NO_VALUES)
def get_metaclasses(self):
args = self._get_bases_arguments()
if args is not None:

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

@@ -2,7 +2,7 @@ import re
import os
from jedi import debug
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.names import ValueNameMixin, AbstractNameDefinition
from jedi.inference.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter
from jedi.inference import compiled
@@ -27,13 +27,13 @@ class _ModuleAttributeName(AbstractNameDefinition):
def infer(self):
if self._string_value is not None:
s = self._string_value
if self.parent_context.infer_state.environment.version_info.major == 2 \
if self.parent_context.inference_state.environment.version_info.major == 2 \
and not isinstance(s, bytes):
s = s.encode('utf-8')
return ValueSet([
create_simple_object(self.parent_context.infer_state, s)
create_simple_object(self.parent_context.inference_state, s)
])
return compiled.get_string_value_set(self.parent_context.infer_state)
return compiled.get_string_value_set(self.parent_context.inference_state)
class ModuleName(ValueNameMixin, AbstractNameDefinition):
@@ -48,9 +48,9 @@ class ModuleName(ValueNameMixin, AbstractNameDefinition):
return self._name
def iter_module_names(infer_state, paths):
def iter_module_names(inference_state, paths):
# Python modules/packages
for n in infer_state.compiled_subprocess.list_module_names(paths):
for n in inference_state.compiled_subprocess.list_module_names(paths):
yield n
for path in paths:
@@ -75,7 +75,7 @@ def iter_module_names(infer_state, paths):
class SubModuleDictMixin(object):
@infer_state_method_cache()
@inference_state_method_cache()
def sub_modules_dict(self):
"""
Lists modules in the directory of this module (if this module is a
@@ -87,7 +87,7 @@ class SubModuleDictMixin(object):
except AttributeError:
pass
else:
mods = iter_module_names(self.infer_state, method())
mods = iter_module_names(self.inference_state, method())
for name in mods:
# It's obviously a relative import to the current module.
names[name] = SubModuleName(self, name)
@@ -113,7 +113,7 @@ class ModuleMixin(SubModuleDictMixin):
yield star_filter
def py__class__(self):
c, = values_from_qualified_names(self.infer_state, u'types', u'ModuleType')
c, = values_from_qualified_names(self.inference_state, u'types', u'ModuleType')
return c
def is_module(self):
@@ -123,7 +123,7 @@ class ModuleMixin(SubModuleDictMixin):
return False
@property
@infer_state_method_cache()
@inference_state_method_cache()
def name(self):
return ModuleName(self, self._string_name)
@@ -140,7 +140,7 @@ class ModuleMixin(SubModuleDictMixin):
# Remove PEP 3149 names
return re.sub(r'\.[a-z]+-\d{2}[mud]{0,3}$', '', r.group(1))
@infer_state_method_cache()
@inference_state_method_cache()
def _module_attributes_dict(self):
names = ['__package__', '__doc__', '__name__']
# All the additional module attributes are strings.
@@ -157,7 +157,7 @@ class ModuleMixin(SubModuleDictMixin):
# I'm not sure if the star import cache is really that effective anymore
# with all the other really fast import caches. Recheck. Also we would need
# to push the star imports into InferenceState.module_cache, if we reenable this.
@infer_state_method_cache([])
@inference_state_method_cache([])
def star_imports(self):
from jedi.inference.imports import Importer
@@ -165,7 +165,7 @@ class ModuleMixin(SubModuleDictMixin):
for i in self.tree_node.iter_imports():
if i.is_star_import():
new = Importer(
self.infer_state,
self.inference_state,
import_path=i.get_paths()[-1],
module_value=self,
level=i.level
@@ -190,9 +190,9 @@ class ModuleValue(ModuleMixin, TreeValue):
api_type = u'module'
parent_context = None
def __init__(self, infer_state, module_node, file_io, string_names, code_lines, is_package=False):
def __init__(self, inference_state, module_node, file_io, string_names, code_lines, is_package=False):
super(ModuleValue, self).__init__(
infer_state,
inference_state,
parent_context=None,
tree_node=module_node
)
@@ -242,7 +242,7 @@ class ModuleValue(ModuleMixin, TreeValue):
# It is a namespace, now try to find the rest of the
# modules on sys_path or whatever the search_path is.
paths = set()
for s in self.infer_state.get_sys_path():
for s in self.inference_state.get_sys_path():
other = os.path.join(s, self.name.string_name)
if os.path.isdir(other):
paths.add(other)

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

@@ -1,4 +1,4 @@
from jedi.inference.cache import infer_state_method_cache
from jedi.inference.cache import inference_state_method_cache
from jedi.inference.filters import DictFilter
from jedi.inference.names import ValueNameMixin, AbstractNameDefinition
from jedi.inference.base_value import Value
@@ -25,9 +25,9 @@ class ImplicitNamespaceValue(Value, SubModuleDictMixin):
api_type = u'module'
parent_context = None
def __init__(self, infer_state, fullname, paths):
super(ImplicitNamespaceValue, self).__init__(infer_state, parent_context=None)
self.infer_state = infer_state
def __init__(self, inference_state, fullname, paths):
super(ImplicitNamespaceValue, self).__init__(inference_state, parent_context=None)
self.inference_state = inference_state
self._fullname = fullname
self._paths = paths
@@ -35,7 +35,7 @@ class ImplicitNamespaceValue(Value, SubModuleDictMixin):
yield DictFilter(self.sub_modules_dict())
@property
@infer_state_method_cache()
@inference_state_method_cache()
def name(self):
string_name = self.py__package__()[-1]
return ImplicitNSName(self, string_name)

10
jedi/plugins/flask.py
View File

@@ -3,19 +3,19 @@ def import_module(callback):
Handle "magic" Flask extension imports:
``flask.ext.foo`` is really ``flask_foo`` or ``flaskext.foo``.
"""
def wrapper(infer_state, import_names, module_value, *args, **kwargs):
def wrapper(inference_state, import_names, module_value, *args, **kwargs):
if len(import_names) == 3 and import_names[:2] == ('flask', 'ext'):
# New style.
ipath = (u'flask_' + import_names[2]),
value_set = callback(infer_state, ipath, None, *args, **kwargs)
value_set = callback(inference_state, ipath, None, *args, **kwargs)
if value_set:
return value_set
value_set = callback(infer_state, (u'flaskext',), None, *args, **kwargs)
value_set = callback(inference_state, (u'flaskext',), None, *args, **kwargs)
return callback(
infer_state,
inference_state,
(u'flaskext', import_names[2]),
next(iter(value_set)),
*args, **kwargs
)
return callback(infer_state, import_names, module_value, *args, **kwargs)
return callback(inference_state, import_names, module_value, *args, **kwargs)
return wrapper

62
jedi/plugins/stdlib.py
View File

@@ -114,7 +114,7 @@ def execute(callback):
except AttributeError:
pass
else:
if value.parent_context == value.infer_state.builtins_module:
if value.parent_context == value.inference_state.builtins_module:
module_name = 'builtins'
elif value.parent_context is not None and value.parent_context.is_module():
module_name = value.parent_context.py__name__()
@@ -148,7 +148,7 @@ def execute(callback):
return wrapper
def _follow_param(infer_state, arguments, index):
def _follow_param(inference_state, arguments, index):
try:
key, lazy_value = list(arguments.unpack())[index]
except IndexError:
@@ -158,7 +158,7 @@ def _follow_param(infer_state, arguments, index):
def argument_clinic(string, want_obj=False, want_value=False,
want_arguments=False, want_infer_state=False,
want_arguments=False, want_inference_state=False,
want_callback=False):
"""
Works like Argument Clinic (PEP 436), to validate function params.
@@ -177,8 +177,8 @@ def argument_clinic(string, want_obj=False, want_value=False,
kwargs['value'] = arguments.value
if want_obj:
kwargs['obj'] = obj
if want_infer_state:
kwargs['infer_state'] = obj.infer_state
if want_inference_state:
kwargs['inference_state'] = obj.inference_state
if want_arguments:
kwargs['arguments'] = arguments
if want_callback:
@@ -202,9 +202,9 @@ def builtins_property(objects, types, obj, arguments):
return lazy_value.infer().py__call__(arguments=ValuesArguments([objects]))
@argument_clinic('iterator[, default], /', want_infer_state=True)
def builtins_next(iterators, defaults, infer_state):
if infer_state.environment.version_info.major == 2:
@argument_clinic('iterator[, default], /', want_inference_state=True)
def builtins_next(iterators, defaults, inference_state):
if inference_state.environment.version_info.major == 2:
name = 'next'
else:
name = '__next__'
@@ -245,8 +245,8 @@ def builtins_type(objects, bases, dicts):
class SuperInstance(LazyValueWrapper):
"""To be used like the object ``super`` returns."""
def __init__(self, infer_state, instance):
self.infer_state = infer_state
def __init__(self, inference_state, instance):
self.inference_state = inference_state
self._instance = instance # Corresponds to super().__self__
def _get_bases(self):
@@ -274,7 +274,7 @@ def builtins_super(types, objects, value):
instance = value.var_args.instance
# TODO if a class is given it doesn't have to be the direct super
# class, it can be an anecestor from long ago.
return ValueSet({SuperInstance(instance.infer_state, instance)})
return ValueSet({SuperInstance(instance.inference_state, instance)})
return NO_VALUES
@@ -312,12 +312,12 @@ def builtins_reversed(sequences, obj, arguments):
# necessary, because `reversed` is a function and autocompletion
# would fail in certain cases like `reversed(x).__iter__` if we
# just returned the result directly.
seq, = obj.infer_state.typing_module.py__getattribute__('Iterator').execute_with_values()
seq, = obj.inference_state.typing_module.py__getattribute__('Iterator').execute_with_values()
return ValueSet([ReversedObject(seq, list(reversed(ordered)))])
@argument_clinic('obj, type, /', want_arguments=True, want_infer_state=True)
def builtins_isinstance(objects, types, arguments, infer_state):
@argument_clinic('obj, type, /', want_arguments=True, want_inference_state=True)
def builtins_isinstance(objects, types, arguments, inference_state):
bool_results = set()
for o in objects:
cls = o.py__class__()
@@ -336,7 +336,7 @@ def builtins_isinstance(objects, types, arguments, infer_state):
if cls_or_tup.is_class():
bool_results.add(cls_or_tup in mro)
elif cls_or_tup.name.string_name == 'tuple' \
and cls_or_tup.get_root_value() == infer_state.builtins_module:
and cls_or_tup.get_root_value() == inference_state.builtins_module:
# Check for tuples.
classes = ValueSet.from_sets(
lazy_value.infer()
@@ -353,7 +353,7 @@ def builtins_isinstance(objects, types, arguments, infer_state):
analysis.add(lazy_value.value, 'type-error-isinstance', node, message)
return ValueSet(
compiled.builtin_from_name(infer_state, force_unicode(str(b)))
compiled.builtin_from_name(inference_state, force_unicode(str(b)))
for b in bool_results
)
@@ -430,18 +430,18 @@ def collections_namedtuple(obj, arguments, callback):
inferring the result.
"""
infer_state = obj.infer_state
inference_state = obj.inference_state
# Process arguments
name = u'jedi_unknown_namedtuple'
for c in _follow_param(infer_state, arguments, 0):
for c in _follow_param(inference_state, arguments, 0):
x = get_str_or_none(c)
if x is not None:
name = force_unicode(x)
break
# TODO here we only use one of the types, we should use all.
param_values = _follow_param(infer_state, arguments, 1)
param_values = _follow_param(inference_state, arguments, 1)
if not param_values:
return NO_VALUES
_fields = list(param_values)[0]
@@ -470,16 +470,16 @@ def collections_namedtuple(obj, arguments, callback):
)
# Parse source code
module = infer_state.grammar.parse(code)
module = inference_state.grammar.parse(code)
generated_class = next(module.iter_classdefs())
parent_context = ModuleValue(
infer_state, module,
inference_state, module,
file_io=None,
string_names=None,
code_lines=parso.split_lines(code, keepends=True),
)
return ValueSet([ClassValue(infer_state, parent_context, generated_class)])
return ValueSet([ClassValue(inference_state, parent_context, generated_class)])
class PartialObject(object):
@@ -571,7 +571,7 @@ def _random_choice(sequences):
def _dataclass(obj, arguments, callback):
for c in _follow_param(obj.infer_state, arguments, 0):
for c in _follow_param(obj.inference_state, arguments, 0):
if c.is_class():
return ValueSet([DataclassWrapper(c)])
else:
@@ -645,7 +645,7 @@ class ItemGetterCallable(ValueWrapper):
value_set |= item_value_set.get_item(lazy_values[0].infer(), None)
else:
value_set |= ValueSet([iterable.FakeSequence(
self._wrapped_value.infer_state,
self._wrapped_value.inference_state,
'list',
[
LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None))
@@ -698,7 +698,7 @@ def _create_string_input_function(func):
s = get_str_or_none(value)
if s is not None:
s = func(s)
yield compiled.create_simple_object(value.infer_state, s)
yield compiled.create_simple_object(value.inference_state, s)
values = ValueSet(iterate())
if values:
return values
@@ -724,7 +724,7 @@ def _os_path_join(args_set, callback):
string += force_unicode(s)
is_first = False
else:
return ValueSet([compiled.create_simple_object(sequence.infer_state, string)])
return ValueSet([compiled.create_simple_object(sequence.inference_state, string)])
return callback()
@@ -803,7 +803,7 @@ def get_metaclass_filters(func):
class EnumInstance(LazyValueWrapper):
def __init__(self, cls, name):
self.infer_state = cls.infer_state
self.inference_state = cls.inference_state
self._cls = cls # Corresponds to super().__self__
self._name = name
self.tree_node = self._name.tree_name
@@ -818,7 +818,7 @@ class EnumInstance(LazyValueWrapper):
def get_filters(self, search_global=False, position=None, origin_scope=None):
yield DictFilter(dict(
name=compiled.create_simple_object(self.infer_state, self._name.string_name).name,
name=compiled.create_simple_object(self.inference_state, self._name.string_name).name,
value=self._name,
))
for f in self._get_wrapped_value().get_filters():
@@ -826,10 +826,10 @@ class EnumInstance(LazyValueWrapper):
def tree_name_to_values(func):
def wrapper(infer_state, value, tree_name):
def wrapper(inference_state, value, tree_name):
if tree_name.value == 'sep' and value.is_module() and value.py__name__() == 'os.path':
return ValueSet({
compiled.create_simple_object(infer_state, os.path.sep),
compiled.create_simple_object(inference_state, os.path.sep),
})
return func(infer_state, value, tree_name)
return func(inference_state, value, tree_name)
return wrapper

4
test/completion/sys_path.py
View File

@@ -13,8 +13,8 @@ sys.path.append('a' +* '/thirdparty')
#? ['inference']
import inference
#? ['infer_state_function_cache']
inference.infer_state_fu
#? ['inference_state_function_cache']
inference.inference_state_fu
# Those don't work because dirname and abspath are not properly understood.
##? ['jedi_']

8
test/conftest.py
View File

@@ -162,10 +162,10 @@ def cwd_tmpdir(monkeypatch, tmpdir):
@pytest.fixture
def infer_state(Script):
return Script('')._infer_state
def inference_state(Script):
return Script('')._inference_state
@pytest.fixture
def same_process_infer_state(Script):
return Script('', environment=InterpreterEnvironment())._infer_state
def same_process_inference_state(Script):
return Script('', environment=InterpreterEnvironment())._inference_state

6
test/run.py
View File

@@ -212,7 +212,7 @@ class IntegrationTestCase(object):
def run_goto_definitions(self, compare_cb, environment):
script = self.script(environment)
infer_state = script._infer_state
inference_state = script._inference_state
def comparison(definition):
suffix = '()' if definition.type == 'instance' else ''
@@ -232,13 +232,13 @@ class IntegrationTestCase(object):
user_value = user_value.get_function_execution()
element.parent = user_value.tree_node
results = convert_values(
infer_state.infer_element(user_value, element),
inference_state.infer_element(user_value, element),
)
if not results:
raise Exception('Could not resolve %s on line %s'
% (match.string, self.line_nr - 1))
should_be |= set(Definition(infer_state, r.name) for r in results)
should_be |= set(Definition(inference_state, r.name) for r in results)
debug.dbg('Finished getting types', color='YELLOW')
# Because the objects have different ids, `repr`, then compare.

20
test/test_api/test_environment.py
View File

@@ -42,10 +42,10 @@ def test_versions(version):
assert env.get_sys_path()
def test_load_module(infer_state):
access_path = infer_state.compiled_subprocess.load_module(
def test_load_module(inference_state):
access_path = inference_state.compiled_subprocess.load_module(
dotted_name=u'math',
sys_path=infer_state.get_sys_path()
sys_path=inference_state.get_sys_path()
)
name, access_handle = access_path.accesses[0]
@@ -55,31 +55,31 @@ def test_load_module(infer_state):
access_handle.py__mro__()
def test_error_in_environment(infer_state, Script, environment):
def test_error_in_environment(inference_state, Script, environment):
if isinstance(environment, InterpreterEnvironment):
pytest.skip("We don't catch these errors at the moment.")
# Provoke an error to show how Jedi can recover from it.
with pytest.raises(jedi.InternalError):
infer_state.compiled_subprocess._test_raise_error(KeyboardInterrupt)
inference_state.compiled_subprocess._test_raise_error(KeyboardInterrupt)
# The second time it should raise an InternalError again.
with pytest.raises(jedi.InternalError):
infer_state.compiled_subprocess._test_raise_error(KeyboardInterrupt)
inference_state.compiled_subprocess._test_raise_error(KeyboardInterrupt)
# Jedi should still work.
def_, = Script('str').goto_definitions()
assert def_.name == 'str'
def test_stdout_in_subprocess(infer_state, Script):
infer_state.compiled_subprocess._test_print(stdout='.')
def test_stdout_in_subprocess(inference_state, Script):
inference_state.compiled_subprocess._test_print(stdout='.')
Script('1').goto_definitions()
def test_killed_subprocess(infer_state, Script, environment):
def test_killed_subprocess(inference_state, Script, environment):
if isinstance(environment, InterpreterEnvironment):
pytest.skip("We cannot kill our own process")
# Just kill the subprocess.
infer_state.compiled_subprocess._compiled_subprocess._get_process().kill()
inference_state.compiled_subprocess._compiled_subprocess._get_process().kill()
# Since the process was terminated (and nobody knows about it) the first
# Jedi call fails.
with pytest.raises(jedi.InternalError):

4
test/test_api/test_project.py
View File

@@ -13,12 +13,12 @@ def test_django_default_project(Script):
)
c, = script.completions()
assert c.name == "SomeModel"
assert script._infer_state.project._django is True
assert script._inference_state.project._django is True
def test_interpreter_project_path():
# Run from anywhere it should be the cwd.
dir = os.path.join(root_dir, 'test')
with set_cwd(dir):
project = Interpreter('', [locals()])._infer_state.project
project = Interpreter('', [locals()])._inference_state.project
assert project._path == dir

2
test/test_api/test_settings.py
View File

@@ -17,7 +17,7 @@ def test_add_dynamic_mods(Script):
# Other fictional modules in another place in the fs.
src2 = 'from .. import setup; setup.r(1)'
script = Script(src1, path='../setup.py')
imports.load_module(script._infer_state, os.path.abspath(fname), src2)
imports.load_module(script._inference_state, os.path.abspath(fname), src2)
result = script.goto_definitions()
assert len(result) == 1
assert result[0].description == 'class int'

2
test/test_inference/test_buildout_detection.py
View File

@@ -63,7 +63,7 @@ def test_sys_path_with_modifications(Script):
""")
path = os.path.abspath(os.path.join(os.curdir, 'module_name.py'))
paths = Script(code, path=path)._infer_state.get_sys_path()
paths = Script(code, path=path)._inference_state.get_sys_path()
assert '/tmp/.buildout/eggs/important_package.egg' in paths

30
test/test_inference/test_compiled.py
View File

@@ -11,8 +11,8 @@ from jedi.inference.compiled.access import DirectObjectAccess
from jedi.inference.gradual.conversion import _stub_to_python_value_set
def test_simple(infer_state, environment):
obj = compiled.create_simple_object(infer_state, u'_str_')
def test_simple(inference_state, environment):
obj = compiled.create_simple_object(inference_state, u'_str_')
upper, = obj.py__getattribute__(u'upper')
objs = list(upper.execute_with_values())
assert len(objs) == 1
@@ -23,15 +23,15 @@ def test_simple(infer_state, environment):
assert objs[0].name.string_name == expected
def test_builtin_loading(infer_state):
string, = infer_state.builtins_module.py__getattribute__(u'str')
def test_builtin_loading(inference_state):
string, = inference_state.builtins_module.py__getattribute__(u'str')
from_name, = string.py__getattribute__(u'__init__')
assert from_name.tree_node
assert not from_name.py__doc__() # It's a stub
def test_next_docstr(infer_state):
next_ = compiled.builtin_from_name(infer_state, u'next')
def test_next_docstr(inference_state):
next_ = compiled.builtin_from_name(inference_state, u'next')
assert next_.tree_node is not None
assert next_.py__doc__() == '' # It's a stub
for non_stub in _stub_to_python_value_set(next_):
@@ -47,12 +47,12 @@ def test_parse_function_doc_illegal_docstr():
assert ('', '') == compiled.value._parse_function_doc(docstr)
def test_doc(infer_state):
def test_doc(inference_state):
"""
Even CompiledObject docs always return empty docstrings - not None, that's
just a Jedi API definition.
"""
str_ = compiled.create_simple_object(infer_state, u'')
str_ = compiled.create_simple_object(inference_state, u'')
# Equals `''.__getnewargs__`
obj, = str_.py__getattribute__(u'__getnewargs__')
assert obj.py__doc__() == ''
@@ -103,7 +103,7 @@ def test_dict_values(Script, environment):
def test_getitem_on_none(Script):
script = Script('None[1j]')
assert not script.goto_definitions()
issue, = script._infer_state.analysis
issue, = script._inference_state.analysis
assert issue.name == 'type-error-not-subscriptable'
@@ -122,7 +122,7 @@ def _return_int():
('ret_int', '_return_int', 'test.test_inference.test_compiled'),
]
)
def test_parent_context(same_process_infer_state, attribute, expected_name, expected_parent):
def test_parent_context(same_process_inference_state, attribute, expected_name, expected_parent):
import decimal
class C:
@@ -135,8 +135,8 @@ def test_parent_context(same_process_infer_state, attribute, expected_name, expe
ret_int = _return_int
o = compiled.CompiledObject(
same_process_infer_state,
DirectObjectAccess(same_process_infer_state, C)
same_process_inference_state,
DirectObjectAccess(same_process_inference_state, C)
)
x, = o.py__getattribute__(attribute)
assert x.py__name__() == expected_name
@@ -163,9 +163,9 @@ def test_parent_context(same_process_infer_state, attribute, expected_name, expe
(Counter("").most_common, ['Counter', 'most_common']),
]
)
def test_qualified_names(same_process_infer_state, obj, expected_names):
def test_qualified_names(same_process_inference_state, obj, expected_names):
o = compiled.CompiledObject(
same_process_infer_state,
DirectObjectAccess(same_process_infer_state, obj)
same_process_inference_state,
DirectObjectAccess(same_process_inference_state, obj)
)
assert o.get_qualified_names() == tuple(expected_names)

4
test/test_inference/test_docstring.py
View File

@@ -66,7 +66,7 @@ def test_instance_doc(Script):
assert defs[0].docstring() == 'Docstring of `TestClass`.'
@unittest.skip('need infer_state class for that')
@unittest.skip('need inference_state class for that')
def test_attribute_docstring(Script):
defs = Script("""
x = None
@@ -75,7 +75,7 @@ def test_attribute_docstring(Script):
assert defs[0].docstring() == 'Docstring of `x`.'
@unittest.skip('need infer_state class for that')
@unittest.skip('need inference_state class for that')
def test_multiple_docstrings(Script):
defs = Script("""
def func():

28
test/test_inference/test_imports.py
View File

@@ -43,12 +43,12 @@ pkg_zip_path = os.path.join(os.path.dirname(__file__),
'pkg.zip')
def test_find_module_package_zipped(Script, infer_state, environment):
def test_find_module_package_zipped(Script, inference_state, environment):
sys_path = environment.get_sys_path() + [pkg_zip_path]
script = Script('import pkg; pkg.mod', sys_path=sys_path)
assert len(script.completions()) == 1
file_io, is_package = infer_state.compiled_subprocess.get_module_info(
file_io, is_package = inference_state.compiled_subprocess.get_module_info(
sys_path=sys_path,
string=u'pkg',
full_name=u'pkg'
@@ -84,7 +84,7 @@ def test_find_module_package_zipped(Script, infer_state, environment):
]
)
def test_correct_zip_package_behavior(Script, infer_state, environment, code,
def test_correct_zip_package_behavior(Script, inference_state, environment, code,
file, package, path, skip_python2):
sys_path = environment.get_sys_path() + [pkg_zip_path]
pkg, = Script(code, sys_path=sys_path).goto_definitions()
@@ -96,13 +96,13 @@ def test_correct_zip_package_behavior(Script, infer_state, environment, code,
assert value.py__path__() == [os.path.join(pkg_zip_path, path)]
def test_find_module_not_package_zipped(Script, infer_state, environment):
def test_find_module_not_package_zipped(Script, inference_state, environment):
path = os.path.join(os.path.dirname(__file__), 'zipped_imports/not_pkg.zip')
sys_path = environment.get_sys_path() + [path]
script = Script('import not_pkg; not_pkg.val', sys_path=sys_path)
assert len(script.completions()) == 1
file_io, is_package = infer_state.compiled_subprocess.get_module_info(
file_io, is_package = inference_state.compiled_subprocess.get_module_info(
sys_path=sys_path,
string=u'not_pkg',
full_name=u'not_pkg'
@@ -310,16 +310,16 @@ def test_compiled_import_none(monkeypatch, Script):
(os.path.join(THIS_DIR, '__init__.py'), True, ('ok', 'lala', 'x', 'test_imports')),
]
)
def test_get_modules_containing_name(infer_state, path, goal, is_package):
def test_get_modules_containing_name(inference_state, path, goal, is_package):
module = imports._load_python_module(
infer_state,
inference_state,
FileIO(path),
import_names=('ok', 'lala', 'x'),
is_package=is_package,
)
assert module
input_module, found_module = imports.get_modules_containing_name(
infer_state,
inference_state,
[module],
'string_that_only_exists_here'
)
@@ -337,9 +337,9 @@ def test_get_modules_containing_name(infer_state, path, goal, is_package):
('/foo/bar/__init__.py', ('foo', 'bar'), True, ('foo', 'bar')),
]
)
def test_load_module_from_path(infer_state, path, base_names, is_package, names):
def test_load_module_from_path(inference_state, path, base_names, is_package, names):
file_io = KnownContentFileIO(path, '')
m = imports._load_module_from_path(infer_state, file_io, base_names)
m = imports._load_module_from_path(inference_state, file_io, base_names)
assert m.is_package == is_package
assert m.string_names == names
@@ -437,8 +437,8 @@ def test_pre_defined_imports_module(Script, environment, name):
module = Script('', path=path)._get_module()
assert module.string_names == (name,)
assert module.infer_state.builtins_module.py__file__() != path
assert module.infer_state.typing_module.py__file__() != path
assert module.inference_state.builtins_module.py__file__() != path
assert module.inference_state.typing_module.py__file__() != path
@pytest.mark.parametrize('name', ('builtins', 'typing'))
@@ -454,8 +454,8 @@ def test_import_needed_modules_by_jedi(Script, environment, tmpdir, name):
sys_path=[tmpdir.strpath] + environment.get_sys_path(),
)
module, = script.goto_definitions()
assert module._infer_state.builtins_module.py__file__() != module_path
assert module._infer_state.typing_module.py__file__() != module_path
assert module._inference_state.builtins_module.py__file__() != module_path
assert module._inference_state.typing_module.py__file__() != module_path
def test_import_with_semicolon(Script):

8
test/test_inference/test_representation.py
View File

@@ -1,9 +1,9 @@
from textwrap import dedent
def get_definition_and_infer_state(Script, source):
def get_definition_and_inference_state(Script, source):
first, = Script(dedent(source)).goto_definitions()
return first._name._value, first._infer_state
return first._name._value, first._inference_state
def test_function_execution(Script):
@@ -16,7 +16,7 @@ def test_function_execution(Script):
def x():
return str()
x"""
func, infer_state = get_definition_and_infer_state(Script, s)
func, inference_state = get_definition_and_inference_state(Script, s)
# Now just use the internals of the result (easiest way to get a fully
# usable function).
# Should return the same result both times.
@@ -29,6 +29,6 @@ def test_class_mro(Script):
class X(object):
pass
X"""
cls, infer_state = get_definition_and_infer_state(Script, s)
cls, inference_state = get_definition_and_inference_state(Script, s)
mro = cls.py__mro__()
assert [c.name.string_name for c in mro] == ['X', 'object']