InferState -> InferenceState

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')

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

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()

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)
             #)

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