diff --git a/jedi/api/__init__.py b/jedi/api/__init__.py index b74364e3..62213efd 100644 --- a/jedi/api/__init__.py +++ b/jedi/api/__init__.py @@ -28,7 +28,7 @@ from jedi.api import helpers from jedi.api.completion import Completion from jedi.api.environment import InterpreterEnvironment from jedi.api.project import get_default_project, Project -from jedi.inference import InferState +from jedi.inference import InferenceState from jedi.inference import imports from jedi.inference import usages from jedi.inference.arguments import try_iter_content @@ -111,7 +111,7 @@ 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 = InferState( + self._infer_state = InferenceState( project, environment=environment, script_path=self.path ) debug.speed('init') diff --git a/jedi/api/environment.py b/jedi/api/environment.py index 278e7494..bd4cebcb 100644 --- a/jedi/api/environment.py +++ b/jedi/api/environment.py @@ -11,7 +11,7 @@ from collections import namedtuple from jedi._compatibility import highest_pickle_protocol, which from jedi.cache import memoize_method, time_cache from jedi.inference.compiled.subprocess import CompiledSubprocess, \ - InferStateSameProcess, InferStateSubprocess + InferenceStateSameProcess, InferenceStateSubprocess import parso @@ -110,7 +110,7 @@ class Environment(_BaseEnvironment): return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path) def get_infer_state_subprocess(self, infer_state): - return InferStateSubprocess(infer_state, self._get_subprocess()) + return InferenceStateSubprocess(infer_state, self._get_subprocess()) @memoize_method def get_sys_path(self): @@ -141,7 +141,7 @@ class SameEnvironment(_SameEnvironmentMixin, Environment): class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment): def get_infer_state_subprocess(self, infer_state): - return InferStateSameProcess(infer_state) + return InferenceStateSameProcess(infer_state) def get_sys_path(self): return sys.path diff --git a/jedi/inference/__init__.py b/jedi/inference/__init__.py index f1ac376f..c12cbbeb 100644 --- a/jedi/inference/__init__.py +++ b/jedi/inference/__init__.py @@ -32,9 +32,9 @@ return the ``date`` class. To *visualize* this (simplified): -- ``InferState.infer_expr_stmt`` doesn't do much, because there's no assignment. +- ``InferenceState.infer_expr_stmt`` doesn't do much, because there's no assignment. - ``Value.infer_node`` cares for resolving the dotted path -- ``InferState.find_types`` searches for global definitions of datetime, which +- ``InferenceState.find_types`` searches for global definitions of datetime, which it finds in the definition of an import, by scanning the syntax tree. - Using the import logic, the datetime module is found. - Now ``find_types`` is called again by ``infer_node`` to find ``date`` @@ -85,7 +85,7 @@ from jedi.inference.syntax_tree import infer_trailer, infer_expr_stmt, \ from jedi.plugins import plugin_manager -class InferState(object): +class InferenceState(object): def __init__(self, project, environment=None, script_path=None): if environment is None: environment = project.get_environment() diff --git a/jedi/inference/compiled/subprocess/__init__.py b/jedi/inference/compiled/subprocess/__init__.py index dfcbfd2a..323bdad7 100644 --- a/jedi/inference/compiled/subprocess/__init__.py +++ b/jedi/inference/compiled/subprocess/__init__.py @@ -70,7 +70,7 @@ def _cleanup_process(process, thread): pass -class _InferStateProcess(object): +class _InferenceStateProcess(object): def __init__(self, infer_state): self._infer_state_weakref = weakref.ref(infer_state) self._infer_state_id = id(infer_state) @@ -93,19 +93,19 @@ class _InferStateProcess(object): self._handles[handle.id] = handle -class InferStateSameProcess(_InferStateProcess): +class InferenceStateSameProcess(_InferenceStateProcess): """ Basically just an easy access to functions.py. It has the same API - as InferStateSubprocess and does the same thing without using a subprocess. + as InferenceStateSubprocess and does the same thing without using a subprocess. This is necessary for the Interpreter process. """ def __getattr__(self, name): return partial(_get_function(name), self._infer_state_weakref()) -class InferStateSubprocess(_InferStateProcess): +class InferenceStateSubprocess(_InferenceStateProcess): def __init__(self, infer_state, compiled_subprocess): - super(InferStateSubprocess, self).__init__(infer_state) + super(InferenceStateSubprocess, self).__init__(infer_state) self._used = False self._compiled_subprocess = compiled_subprocess @@ -288,17 +288,17 @@ class Listener(object): self._infer_states = {} # TODO refactor so we don't need to process anymore just handle # controlling. - self._process = _InferStateProcess(Listener) + self._process = _InferenceStateProcess(Listener) self._pickle_protocol = pickle_protocol def _get_infer_state(self, function, infer_state_id): - from jedi.inference import InferState + from jedi.inference import InferenceState try: infer_state = self._infer_states[infer_state_id] except KeyError: from jedi.api.environment import InterpreterEnvironment - infer_state = InferState( + infer_state = InferenceState( # The project is not actually needed. Nothing should need to # access it. project=None, @@ -399,7 +399,7 @@ class AccessHandle(object): @memoize_method def _cached_results(self, name, *args, **kwargs): - #if type(self._subprocess) == InferStateSubprocess: + #if type(self._subprocess) == InferenceStateSubprocess: #print(name, args, kwargs, #self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs) #) diff --git a/jedi/inference/value/module.py b/jedi/inference/value/module.py index 3a4e04e7..f0268471 100644 --- a/jedi/inference/value/module.py +++ b/jedi/inference/value/module.py @@ -156,7 +156,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 InferState.module_cache, if we reenable this. + # to push the star imports into InferenceState.module_cache, if we reenable this. @infer_state_method_cache([]) def star_imports(self): from jedi.inference.imports import Importer