Move the evaluate package to inference

.coveragerc

@@ -1,7 +1,7 @@
 [run]
 omit =
     jedi/_compatibility.py
-    jedi/evaluate/compiled/subprocess/__main__.py
+    jedi/inference/compiled/subprocess/__main__.py
     jedi/__main__.py
     # For now this is not being used.
     jedi/refactoring.py

conftest.py

@@ -12,7 +12,7 @@ from jedi._compatibility import py_version
 collect_ignore = [
     'setup.py',
     '__main__.py',
-    'jedi/evaluate/compiled/subprocess/__main__.py',
+    'jedi/inference/compiled/subprocess/__main__.py',
     'build/',
     'test/examples',
 ]

docs/docs/development.rst

@@ -47,12 +47,12 @@ The Jedi Core
 The core of Jedi consists of three parts:
 
 - :ref:`Parser <parser>`
-- :ref:`Python type inference <evaluate>`
+- :ref:`Python type inference <inference>`
 - :ref:`API <dev-api>`
 
-Most people are probably interested in :ref:`type inference <evaluate>`,
+Most people are probably interested in :ref:`type inference <inference>`,
 because that's where all the magic happens. I need to introduce the :ref:`parser
-<parser>` first, because :mod:`jedi.evaluate` uses it extensively.
+<parser>` first, because :mod:`jedi.inference` uses it extensively.
 
 .. _parser:
 
@@ -66,32 +66,32 @@ The parser creates a syntax tree that |jedi| analyses and tries to understand.
 The grammar that this parsers uses is very similar to the official Python
 `grammar files <https://docs.python.org/3/reference/grammar.html>`_.
 
-.. _evaluate:
+.. _inference:
 
-Type inference of python code (evaluate/__init__.py)
+Type inference of python code (inference/__init__.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate
+.. automodule:: jedi.inference
 
-Inference Contexts (evaluate/base_context.py)
+Inference Contexts (inference/base_context.py)
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-.. automodule:: jedi.evaluate.base_context
+.. automodule:: jedi.inference.base_context
 
 .. inheritance-diagram::
-   jedi.evaluate.context.instance.TreeInstance
+   jedi.inference.context.instance.TreeInstance
-   jedi.evaluate.context.klass.ClassContext
+   jedi.inference.context.klass.ClassContext
-   jedi.evaluate.context.function.FunctionContext
+   jedi.inference.context.function.FunctionContext
-   jedi.evaluate.context.function.FunctionExecutionContext
+   jedi.inference.context.function.FunctionExecutionContext
    :parts: 1
 
 
 .. _name_resolution:
 
-Name resolution (evaluate/finder.py)
+Name resolution (inference/finder.py)
 ++++++++++++++++++++++++++++++++++++
 
-.. automodule:: jedi.evaluate.finder
+.. automodule:: jedi.inference.finder
 
 
 .. _dev-api:
@@ -124,33 +124,33 @@ without some features.
 
 .. _iterables:
 
-Iterables & Dynamic Arrays (evaluate/context/iterable.py)
+Iterables & Dynamic Arrays (inference/context/iterable.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 To understand Python on a deeper level, |jedi| needs to understand some of the
 dynamic features of Python like lists that are filled after creation:
 
-.. automodule:: jedi.evaluate.context.iterable
+.. automodule:: jedi.inference.context.iterable
 
 
 .. _dynamic:
 
-Parameter completion (evaluate/dynamic.py)
+Parameter completion (inference/dynamic.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.dynamic
+.. automodule:: jedi.inference.dynamic
 
 
 .. _docstrings:
 
-Docstrings (evaluate/docstrings.py)
+Docstrings (inference/docstrings.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.docstrings
+.. automodule:: jedi.inference.docstrings
 
 .. _refactoring:
 
-Refactoring (evaluate/refactoring.py)
+Refactoring (inference/refactoring.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.refactoring
@@ -169,18 +169,18 @@ Imports & Modules
 
 .. _builtin:
 
-Compiled Modules (evaluate/compiled.py)
+Compiled Modules (inference/compiled.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.compiled
+.. automodule:: jedi.inference.compiled
 
 
 .. _imports:
 
-Imports (evaluate/imports.py)
+Imports (inference/imports.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.imports
+.. automodule:: jedi.inference.imports
 
 
 .. _caching-recursions:
@@ -204,7 +204,7 @@ Caching (cache.py)
 Recursions (recursion.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. automodule:: jedi.evaluate.recursion
+.. automodule:: jedi.inference.recursion
 
 
 .. _dev-helpers:

jedi/api/__init__.py

@@ -28,19 +28,19 @@ 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.evaluate import Evaluator
+from jedi.inference import Evaluator
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate import usages
+from jedi.inference import usages
-from jedi.evaluate.arguments import try_iter_content
+from jedi.inference.arguments import try_iter_content
-from jedi.evaluate.helpers import get_module_names, evaluate_call_of_leaf
+from jedi.inference.helpers import get_module_names, infer_call_of_leaf
-from jedi.evaluate.sys_path import transform_path_to_dotted
+from jedi.inference.sys_path import transform_path_to_dotted
-from jedi.evaluate.names import TreeNameDefinition, ParamName
+from jedi.inference.names import TreeNameDefinition, ParamName
-from jedi.evaluate.syntax_tree import tree_name_to_contexts
+from jedi.inference.syntax_tree import tree_name_to_contexts
-from jedi.evaluate.context import ModuleContext
+from jedi.inference.context import ModuleContext
-from jedi.evaluate.base_context import ContextSet
+from jedi.inference.base_context import ContextSet
-from jedi.evaluate.context.iterable import unpack_tuple_to_dict
+from jedi.inference.context.iterable import unpack_tuple_to_dict
-from jedi.evaluate.gradual.conversion import convert_names, convert_contexts
+from jedi.inference.gradual.conversion import convert_names, convert_contexts
-from jedi.evaluate.gradual.utils import load_proper_stub_module
+from jedi.inference.gradual.utils import load_proper_stub_module
 
 # Jedi uses lots and lots of recursion. By setting this a little bit higher, we
 # can remove some "maximum recursion depth" errors.
@@ -62,7 +62,7 @@ class Script(object):
 
     - if `sys_path` parameter is ``None`` and ``VIRTUAL_ENV`` environment
       variable is defined, ``sys.path`` for the specified environment will be
-      guessed (see :func:`jedi.evaluate.sys_path.get_venv_path`) and used for
+      guessed (see :func:`jedi.inference.sys_path.get_venv_path`) and used for
       the script;
 
     - otherwise ``sys.path`` will match that of |jedi|.
@@ -241,7 +241,7 @@ class Script(object):
 
         context = self._evaluator.create_context(self._get_module(), leaf)
 
-        contexts = helpers.evaluate_goto_definition(self._evaluator, context, leaf)
+        contexts = helpers.infer_goto_definition(self._evaluator, context, leaf)
         contexts = convert_contexts(
             contexts,
             only_stubs=only_stubs,
@@ -411,7 +411,7 @@ class Script(object):
                     if node.type == 'name':
                         defs = self._evaluator.goto_definitions(context, node)
                     else:
-                        defs = evaluate_call_of_leaf(context, node)
+                        defs = infer_call_of_leaf(context, node)
                     try_iter_content(defs)
                 self._evaluator.reset_recursion_limitations()
 

jedi/api/classes.py

@@ -9,15 +9,15 @@ import warnings
 
 from jedi import settings
 from jedi import debug
-from jedi.evaluate.utils import unite
+from jedi.inference.utils import unite
 from jedi.cache import memoize_method
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.imports import ImportName
+from jedi.inference.imports import ImportName
-from jedi.evaluate.context import FunctionExecutionContext
+from jedi.inference.context import FunctionExecutionContext
-from jedi.evaluate.gradual.typeshed import StubModuleContext
+from jedi.inference.gradual.typeshed import StubModuleContext
-from jedi.evaluate.gradual.conversion import convert_names, convert_contexts
+from jedi.inference.gradual.conversion import convert_names, convert_contexts
-from jedi.evaluate.base_context import ContextSet
+from jedi.inference.base_context import ContextSet
 from jedi.api.keywords import KeywordName
 
 

jedi/api/completion.py

@@ -11,10 +11,10 @@ from jedi.api import classes
 from jedi.api import helpers
 from jedi.api import keywords
 from jedi.api.file_name import file_name_completions
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate.helpers import evaluate_call_of_leaf, parse_dotted_names
+from jedi.inference.helpers import infer_call_of_leaf, parse_dotted_names
-from jedi.evaluate.filters import get_global_filters
+from jedi.inference.filters import get_global_filters
-from jedi.evaluate.gradual.conversion import convert_contexts
+from jedi.inference.gradual.conversion import convert_contexts
 from jedi.parser_utils import get_statement_of_position, cut_value_at_position
 
 
@@ -256,7 +256,7 @@ class Completion:
         inferred_context = self._evaluator.create_context(
             self._module_context, previous_leaf
         )
-        contexts = evaluate_call_of_leaf(inferred_context, previous_leaf)
+        contexts = infer_call_of_leaf(inferred_context, previous_leaf)
         completion_names = []
         debug.dbg('trailer completion contexts: %s', contexts, color='MAGENTA')
         for context in contexts:

jedi/api/environment.py

@@ -10,7 +10,7 @@ from collections import namedtuple
 
 from jedi._compatibility import highest_pickle_protocol, which
 from jedi.cache import memoize_method, time_cache
-from jedi.evaluate.compiled.subprocess import CompiledSubprocess, \
+from jedi.inference.compiled.subprocess import CompiledSubprocess, \
     EvaluatorSameProcess, EvaluatorSubprocess
 
 import parso

jedi/api/file_name.py

@@ -1,9 +1,9 @@
 import os
 
 from jedi._compatibility import FileNotFoundError, force_unicode
-from jedi.evaluate.names import AbstractArbitraryName
+from jedi.inference.names import AbstractArbitraryName
 from jedi.api import classes
-from jedi.evaluate.helpers import get_str_or_none
+from jedi.inference.helpers import get_str_or_none
 from jedi.parser_utils import get_string_quote
 
 

jedi/api/helpers.py

@@ -9,10 +9,10 @@ from parso.python.parser import Parser
 from parso.python import tree
 
 from jedi._compatibility import u, Parameter
-from jedi.evaluate.base_context import NO_CONTEXTS
+from jedi.inference.base_context import NO_CONTEXTS
-from jedi.evaluate.syntax_tree import eval_atom
+from jedi.inference.syntax_tree import eval_atom
-from jedi.evaluate.helpers import evaluate_call_of_leaf
+from jedi.inference.helpers import infer_call_of_leaf
-from jedi.evaluate.compiled import get_string_context_set
+from jedi.inference.compiled import get_string_context_set
 from jedi.cache import call_signature_time_cache
 
 
@@ -136,7 +136,7 @@ def get_stack_at_position(grammar, code_lines, leaf, pos):
     )
 
 
-def evaluate_goto_definition(evaluator, context, leaf):
+def infer_goto_definition(evaluator, context, leaf):
     if leaf.type == 'name':
         # In case of a name we can just use goto_definition which does all the
         # magic itself.
@@ -149,7 +149,7 @@ def evaluate_goto_definition(evaluator, context, leaf):
         definitions = context.eval_node(leaf.parent)
     elif parent.type == 'trailer':
         # e.g. `a()`
-        definitions = evaluate_call_of_leaf(context, leaf)
+        definitions = infer_call_of_leaf(context, leaf)
     elif isinstance(leaf, tree.Literal):
         # e.g. `"foo"` or `1.0`
         return eval_atom(context, leaf)
@@ -390,7 +390,7 @@ def cache_call_signatures(evaluator, context, bracket_leaf, code_lines, user_pos
         yield None  # Don't cache!
     else:
         yield (module_path, before_bracket, bracket_leaf.start_pos)
-    yield evaluate_goto_definition(
+    yield infer_goto_definition(
         evaluator,
         context,
         bracket_leaf.get_previous_leaf(),

jedi/api/interpreter.py

@@ -2,11 +2,11 @@
 TODO Some parts of this module are still not well documented.
 """
 
-from jedi.evaluate.context import ModuleContext
+from jedi.inference.context import ModuleContext
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.compiled import mixed
+from jedi.inference.compiled import mixed
-from jedi.evaluate.compiled.access import create_access_path
+from jedi.inference.compiled.access import create_access_path
-from jedi.evaluate.base_context import ContextWrapper
+from jedi.inference.base_context import ContextWrapper
 
 
 def _create(evaluator, obj):

jedi/api/keywords.py

@@ -1,7 +1,7 @@
 import pydoc
 
-from jedi.evaluate.utils import ignored
+from jedi.inference.utils import ignored
-from jedi.evaluate.names import AbstractArbitraryName
+from jedi.inference.names import AbstractArbitraryName
 
 try:
     from pydoc_data import topics as pydoc_topics

jedi/api/project.py

@@ -6,8 +6,8 @@ from jedi.api.environment import SameEnvironment, \
     get_cached_default_environment
 from jedi.api.exceptions import WrongVersion
 from jedi._compatibility import force_unicode
-from jedi.evaluate.sys_path import discover_buildout_paths
+from jedi.inference.sys_path import discover_buildout_paths
-from jedi.evaluate.cache import evaluator_as_method_param_cache
+from jedi.inference.cache import evaluator_as_method_param_cache
 from jedi.common.utils import traverse_parents
 
 _CONFIG_FOLDER = '.jedi'

jedi/evaluate/context/__init__.py

@@ -1,6 +0,0 @@
-from jedi.evaluate.context.module import ModuleContext
-from jedi.evaluate.context.klass import ClassContext
-from jedi.evaluate.context.function import FunctionContext, \
-    MethodContext, FunctionExecutionContext
-from jedi.evaluate.context.instance import AnonymousInstance, BoundMethod, \
-    CompiledInstance, AbstractInstanceContext, TreeInstance

jedi/inference/__init__.py

@@ -69,18 +69,18 @@ from jedi.file_io import FileIO
 
 from jedi import debug
 from jedi import parser_utils
-from jedi.evaluate.utils import unite
+from jedi.inference.utils import unite
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate import recursion
+from jedi.inference import recursion
-from jedi.evaluate.cache import evaluator_function_cache
+from jedi.inference.cache import evaluator_function_cache
-from jedi.evaluate import helpers
+from jedi.inference import helpers
-from jedi.evaluate.names import TreeNameDefinition, ParamName
+from jedi.inference.names import TreeNameDefinition, ParamName
-from jedi.evaluate.base_context import ContextualizedName, ContextualizedNode, \
+from jedi.inference.base_context import ContextualizedName, ContextualizedNode, \
     ContextSet, NO_CONTEXTS, iterate_contexts
-from jedi.evaluate.context import ClassContext, FunctionContext, \
+from jedi.inference.context import ClassContext, FunctionContext, \
     AnonymousInstance, BoundMethod
-from jedi.evaluate.context.iterable import CompForContext
+from jedi.inference.context.iterable import CompForContext
-from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, \
+from jedi.inference.syntax_tree import eval_trailer, eval_expr_stmt, \
     eval_node, check_tuple_assignments
 from jedi.plugins import plugin_manager
 
@@ -98,9 +98,9 @@ class Evaluator(object):
         self.memoize_cache = {}  # for memoize decorators
         self.module_cache = imports.ModuleCache()  # does the job of `sys.modules`.
         self.stub_module_cache = {}  # Dict[Tuple[str, ...], Optional[ModuleContext]]
-        self.compiled_cache = {}  # see `evaluate.compiled.create()`
+        self.compiled_cache = {}  # see `inference.compiled.create()`
         self.inferred_element_counts = {}
-        self.mixed_cache = {}  # see `evaluate.compiled.mixed._create()`
+        self.mixed_cache = {}  # see `inference.compiled.mixed._create()`
         self.analysis = []
         self.dynamic_params_depth = 0
         self.is_analysis = False
@@ -190,7 +190,7 @@ class Evaluator(object):
                             if len(name_dicts) * len(definitions) > 16:
                                 debug.dbg('Too many options for if branch inference %s.', if_stmt)
                                 # There's only a certain amount of branches
-                                # Jedi can evaluate, otherwise it will take to
+                                # Jedi can infer, otherwise it will take to
                                 # long.
                                 name_dicts = [{}]
                                 break
@@ -266,7 +266,7 @@ class Evaluator(object):
             if result is not None:
                 return result
 
-        return helpers.evaluate_call_of_leaf(context, name)
+        return helpers.infer_call_of_leaf(context, name)
 
     def _follow_error_node_imports_if_possible(self, context, name):
         error_node = tree.search_ancestor(name, 'error_node')
@@ -329,11 +329,11 @@ class Evaluator(object):
                     context_set = context.eval_node(trailer.children[1])
                 else:
                     i = trailer.parent.children.index(trailer)
-                    to_evaluate = trailer.parent.children[:i]
+                    to_infer = trailer.parent.children[:i]
-                    if to_evaluate[0] == 'await':
+                    if to_infer[0] == 'await':
-                        to_evaluate.pop(0)
+                        to_infer.pop(0)
-                    context_set = context.eval_node(to_evaluate[0])
+                    context_set = context.eval_node(to_infer[0])
-                    for trailer in to_evaluate[1:]:
+                    for trailer in to_infer[1:]:
                         context_set = eval_trailer(context, context_set, trailer)
                 param_names = []
                 for context in context_set:
@@ -354,7 +354,7 @@ class Evaluator(object):
                 )
 
         if node_type == 'trailer' and par.children[0] == '.':
-            values = helpers.evaluate_call_of_leaf(context, name, cut_own_trailer=True)
+            values = helpers.infer_call_of_leaf(context, name, cut_own_trailer=True)
             return values.py__getattribute__(name, name_context=context, is_goto=True)
         else:
             stmt = tree.search_ancestor(

jedi/inference/analysis.py

@@ -5,7 +5,7 @@ from parso.python import tree
 
 from jedi._compatibility import force_unicode
 from jedi import debug
-from jedi.evaluate.helpers import is_string
+from jedi.inference.helpers import is_string
 
 
 CODES = {
@@ -114,7 +114,7 @@ def _check_for_setattr(instance):
 
 def add_attribute_error(name_context, lookup_context, name):
     message = ('AttributeError: %s has no attribute %s.' % (lookup_context, name))
-    from jedi.evaluate.context.instance import CompiledInstanceName
+    from jedi.inference.context.instance import CompiledInstanceName
     # Check for __getattr__/__getattribute__ existance and issue a warning
     # instead of an error, if that happens.
     typ = Error
@@ -169,7 +169,7 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
             else:
                 except_classes = node_context.eval_node(node)
                 for cls in except_classes:
-                    from jedi.evaluate.context import iterable
+                    from jedi.inference.context import iterable
                     if isinstance(cls, iterable.Sequence) and \
                             cls.array_type == 'tuple':
                         # multiple exceptions
@@ -191,7 +191,7 @@ def _check_for_exception_catch(node_context, jedi_name, exception, payload=None)
             assert trailer.type == 'trailer'
             arglist = trailer.children[1]
             assert arglist.type == 'arglist'
-            from jedi.evaluate.arguments import TreeArguments
+            from jedi.inference.arguments import TreeArguments
             args = list(TreeArguments(node_context.evaluator, node_context, arglist).unpack())
             # Arguments should be very simple
             assert len(args) == 2

jedi/inference/arguments.py

@@ -4,15 +4,15 @@ from parso.python import tree
 
 from jedi._compatibility import zip_longest
 from jedi import debug
-from jedi.evaluate.utils import PushBackIterator
+from jedi.inference.utils import PushBackIterator
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \
+from jedi.inference.lazy_context import LazyKnownContext, LazyKnownContexts, \
     LazyTreeContext, get_merged_lazy_context
-from jedi.evaluate.names import ParamName, TreeNameDefinition
+from jedi.inference.names import ParamName, TreeNameDefinition
-from jedi.evaluate.base_context import NO_CONTEXTS, ContextSet, ContextualizedNode
+from jedi.inference.base_context import NO_CONTEXTS, ContextSet, ContextualizedNode
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
-from jedi.evaluate.cache import evaluator_as_method_param_cache
+from jedi.inference.cache import evaluator_as_method_param_cache
-from jedi.evaluate.param import get_executed_params_and_issues, ExecutedParam
+from jedi.inference.param import get_executed_params_and_issues, ExecutedParam
 
 
 def try_iter_content(types, depth=0):
@@ -134,7 +134,7 @@ def _parse_argument_clinic(string):
 class _AbstractArgumentsMixin(object):
     def eval_all(self, funcdef=None):
         """
-        Evaluates all arguments as a support for static analysis
+        Inferes all arguments as a support for static analysis
         (normally Jedi).
         """
         for key, lazy_context in self.unpack():
@@ -159,7 +159,7 @@ class AbstractArguments(_AbstractArgumentsMixin):
 
 class AnonymousArguments(AbstractArguments):
     def get_executed_params_and_issues(self, execution_context):
-        from jedi.evaluate.dynamic import search_params
+        from jedi.inference.dynamic import search_params
         return search_params(
             execution_context.evaluator,
             execution_context,
@@ -275,7 +275,7 @@ class TreeArguments(AbstractArguments):
         return '<%s: %s>' % (self.__class__.__name__, self.argument_node)
 
     def get_calling_nodes(self):
-        from jedi.evaluate.dynamic import DynamicExecutedParams
+        from jedi.inference.dynamic import DynamicExecutedParams
         old_arguments_list = []
         arguments = self
 
@@ -363,7 +363,7 @@ def _iterate_star_args(context, array, input_node, funcdef=None):
 
 
 def _star_star_dict(context, array, input_node, funcdef):
-    from jedi.evaluate.context.instance import CompiledInstance
+    from jedi.inference.context.instance import CompiledInstance
     if isinstance(array, CompiledInstance) and array.name.string_name == 'dict':
         # For now ignore this case. In the future add proper iterators and just
         # make one call without crazy isinstance checks.

jedi/inference/base_context.py

@@ -14,9 +14,9 @@ from jedi import debug
 from jedi._compatibility import zip_longest, unicode
 from jedi.parser_utils import clean_scope_docstring
 from jedi.common import BaseContextSet, BaseContext
-from jedi.evaluate.helpers import SimpleGetItemNotFound
+from jedi.inference.helpers import SimpleGetItemNotFound
-from jedi.evaluate.utils import safe_property
+from jedi.inference.utils import safe_property
-from jedi.evaluate.cache import evaluator_as_method_param_cache
+from jedi.inference.cache import evaluator_as_method_param_cache
 from jedi.cache import memoize_method
 
 _sentinel = object()
@@ -39,7 +39,7 @@ class HelperContextMixin(object):
         return self.evaluator.execute(self, arguments=arguments)
 
     def execute_with_values(self, *value_list):
-        from jedi.evaluate.arguments import ValuesArguments
+        from jedi.inference.arguments import ValuesArguments
         arguments = ValuesArguments([ContextSet([value]) for value in value_list])
         return self.evaluator.execute(self, arguments)
 
@@ -63,7 +63,7 @@ class HelperContextMixin(object):
         """
         if name_context is None:
             name_context = self
-        from jedi.evaluate import finder
+        from jedi.inference import finder
         f = finder.NameFinder(self.evaluator, self, name_context, name_or_str,
                               position, analysis_errors=analysis_errors)
         filters = f.get_filters(search_global)
@@ -86,7 +86,7 @@ class HelperContextMixin(object):
     def iterate(self, contextualized_node=None, is_async=False):
         debug.dbg('iterate %s', self)
         if is_async:
-            from jedi.evaluate.lazy_context import LazyKnownContexts
+            from jedi.inference.lazy_context import LazyKnownContexts
             # TODO if no __aiter__ contexts are there, error should be:
             # TypeError: 'async for' requires an object with __aiter__ method, got int
             return iter([
@@ -129,7 +129,7 @@ class Context(HelperContextMixin, BaseContext):
         return self.__class__.__name__.lower()
 
     def py__getitem__(self, index_context_set, contextualized_node):
-        from jedi.evaluate import analysis
+        from jedi.inference import analysis
         # TODO this context is probably not right.
         analysis.add(
             contextualized_node.context,
@@ -141,7 +141,7 @@ class Context(HelperContextMixin, BaseContext):
 
     def py__iter__(self, contextualized_node=None):
         if contextualized_node is not None:
-            from jedi.evaluate import analysis
+            from jedi.inference import analysis
             analysis.add(
                 contextualized_node.context,
                 'type-error-not-iterable',
@@ -227,12 +227,12 @@ class _ContextWrapperBase(HelperContextMixin):
 
     @safe_property
     def name(self):
-        from jedi.evaluate.names import ContextName
+        from jedi.inference.names import ContextName
         wrapped_name = self._wrapped_context.name
         if wrapped_name.tree_name is not None:
             return ContextName(self, wrapped_name.tree_name)
         else:
-            from jedi.evaluate.compiled import CompiledContextName
+            from jedi.inference.compiled import CompiledContextName
             return CompiledContextName(self, wrapped_name.string_name)
 
     @classmethod
@@ -341,7 +341,7 @@ class ContextualizedName(ContextualizedNode):
 
 
 def _getitem(context, index_contexts, contextualized_node):
-    from jedi.evaluate.context.iterable import Slice
+    from jedi.inference.context.iterable import Slice
 
     # The actual getitem call.
     simple_getitem = getattr(context, 'py__simple_getitem__', None)
@@ -387,7 +387,7 @@ class ContextSet(BaseContextSet):
         return ContextSet(c.py__class__() for c in self._set)
 
     def iterate(self, contextualized_node=None, is_async=False):
-        from jedi.evaluate.lazy_context import get_merged_lazy_context
+        from jedi.inference.lazy_context import get_merged_lazy_context
         type_iters = [c.iterate(contextualized_node, is_async=is_async) for c in self._set]
         for lazy_contexts in zip_longest(*type_iters):
             yield get_merged_lazy_context(

jedi/inference/compiled/__init__.py

@@ -1,7 +1,7 @@
 from jedi._compatibility import unicode
-from jedi.evaluate.compiled.context import CompiledObject, CompiledName, \
+from jedi.inference.compiled.context import CompiledObject, CompiledName, \
     CompiledObjectFilter, CompiledContextName, create_from_access_path
-from jedi.evaluate.base_context import ContextWrapper, LazyContextWrapper
+from jedi.inference.base_context import ContextWrapper, LazyContextWrapper
 
 
 def builtin_from_name(evaluator, string):

jedi/inference/compiled/access.py

@@ -7,7 +7,7 @@ from collections import namedtuple
 
 from jedi._compatibility import unicode, is_py3, builtins, \
     py_version, force_unicode
-from jedi.evaluate.compiled.getattr_static import getattr_static
+from jedi.inference.compiled.getattr_static import getattr_static
 
 ALLOWED_GETITEM_TYPES = (str, list, tuple, unicode, bytes, bytearray, dict)
 

jedi/inference/compiled/context.py

@@ -5,18 +5,18 @@ import re
 from functools import partial
 
 from jedi import debug
-from jedi.evaluate.utils import to_list
+from jedi.inference.utils import to_list
 from jedi._compatibility import force_unicode, Parameter, cast_path
 from jedi.cache import underscore_memoization, memoize_method
-from jedi.evaluate.filters import AbstractFilter
+from jedi.inference.filters import AbstractFilter
-from jedi.evaluate.names import AbstractNameDefinition, ContextNameMixin, \
+from jedi.inference.names import AbstractNameDefinition, ContextNameMixin, \
     ParamNameInterface
-from jedi.evaluate.base_context import Context, ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import Context, ContextSet, NO_CONTEXTS
-from jedi.evaluate.lazy_context import LazyKnownContext
+from jedi.inference.lazy_context import LazyKnownContext
-from jedi.evaluate.compiled.access import _sentinel
+from jedi.inference.compiled.access import _sentinel
-from jedi.evaluate.cache import evaluator_function_cache
+from jedi.inference.cache import evaluator_function_cache
-from jedi.evaluate.helpers import reraise_getitem_errors
+from jedi.inference.helpers import reraise_getitem_errors
-from jedi.evaluate.signature import BuiltinSignature
+from jedi.inference.signature import BuiltinSignature
 
 
 class CheckAttribute(object):
@@ -57,7 +57,7 @@ class CompiledObject(Context):
             return super(CompiledObject, self).py__call__(arguments)
         else:
             if self.access_handle.is_class():
-                from jedi.evaluate.context import CompiledInstance
+                from jedi.inference.context import CompiledInstance
                 return ContextSet([
                     CompiledInstance(self.evaluator, self.parent_context, self, arguments)
                 ])
@@ -228,8 +228,8 @@ class CompiledObject(Context):
         return CompiledContextName(self, name)
 
     def _execute_function(self, params):
-        from jedi.evaluate import docstrings
+        from jedi.inference import docstrings
-        from jedi.evaluate.compiled import builtin_from_name
+        from jedi.inference.compiled import builtin_from_name
         if self.api_type != 'function':
             return
 
@@ -414,7 +414,7 @@ class CompiledObjectFilter(AbstractFilter):
             return self._create_name(name)
 
     def values(self):
-        from jedi.evaluate.compiled import builtin_from_name
+        from jedi.inference.compiled import builtin_from_name
         names = []
         needs_type_completions, dir_infos = self.compiled_object.access_handle.get_dir_infos()
         for name in dir_infos:

jedi/inference/compiled/mixed.py

@@ -9,18 +9,18 @@ import sys
 from jedi.parser_utils import get_cached_code_lines
 
 from jedi import settings
-from jedi.evaluate import compiled
+from jedi.inference import compiled
 from jedi.cache import underscore_memoization
 from jedi.file_io import FileIO
-from jedi.evaluate.base_context import ContextSet, ContextWrapper
+from jedi.inference.base_context import ContextSet, ContextWrapper
-from jedi.evaluate.helpers import SimpleGetItemNotFound
+from jedi.inference.helpers import SimpleGetItemNotFound
-from jedi.evaluate.context import ModuleContext
+from jedi.inference.context import ModuleContext
-from jedi.evaluate.cache import evaluator_function_cache
+from jedi.inference.cache import evaluator_function_cache
-from jedi.evaluate.compiled.getattr_static import getattr_static
+from jedi.inference.compiled.getattr_static import getattr_static
-from jedi.evaluate.compiled.access import compiled_objects_cache, \
+from jedi.inference.compiled.access import compiled_objects_cache, \
     ALLOWED_GETITEM_TYPES, get_api_type
-from jedi.evaluate.compiled.context import create_cached_compiled_object
+from jedi.inference.compiled.context import create_cached_compiled_object
-from jedi.evaluate.gradual.conversion import to_stub
+from jedi.inference.gradual.conversion import to_stub
 
 _sentinel = object()
 

jedi/inference/compiled/subprocess/__init__.py

@@ -24,8 +24,8 @@ from jedi._compatibility import queue, is_py3, force_unicode, \
     pickle_dump, pickle_load, GeneralizedPopen, weakref
 from jedi import debug
 from jedi.cache import memoize_method
-from jedi.evaluate.compiled.subprocess import functions
+from jedi.inference.compiled.subprocess import functions
-from jedi.evaluate.compiled.access import DirectObjectAccess, AccessPath, \
+from jedi.inference.compiled.access import DirectObjectAccess, AccessPath, \
     SignatureParam
 from jedi.api.exceptions import InternalError
 
@@ -292,7 +292,7 @@ class Listener(object):
         self._pickle_protocol = pickle_protocol
 
     def _get_evaluator(self, function, evaluator_id):
-        from jedi.evaluate import Evaluator
+        from jedi.inference import Evaluator
 
         try:
             evaluator = self._evaluators[evaluator_id]

jedi/inference/compiled/subprocess/__main__.py

@@ -31,7 +31,7 @@ if sys.version_info > (3, 4):
 
     # Try to import jedi/parso.
     sys.meta_path.insert(0, _ExactImporter(_get_paths()))
-    from jedi.evaluate.compiled import subprocess  # NOQA
+    from jedi.inference.compiled import subprocess  # NOQA
     sys.meta_path.pop(0)
 else:
     import imp
@@ -43,7 +43,7 @@ else:
 
     load('parso')
     load('jedi')
-    from jedi.evaluate.compiled import subprocess  # NOQA
+    from jedi.inference.compiled import subprocess  # NOQA
 
 from jedi._compatibility import highest_pickle_protocol  # noqa: E402
 

jedi/inference/compiled/subprocess/functions.py

@@ -4,7 +4,7 @@ import os
 
 from jedi._compatibility import find_module, cast_path, force_unicode, \
     iter_modules, all_suffixes
-from jedi.evaluate.compiled import access
+from jedi.inference.compiled import access
 from jedi import parser_utils
 
 

jedi/inference/context/__init__.py

@@ -0,0 +1,6 @@
+from jedi.inference.context.module import ModuleContext
+from jedi.inference.context.klass import ClassContext
+from jedi.inference.context.function import FunctionContext, \
+    MethodContext, FunctionExecutionContext
+from jedi.inference.context.instance import AnonymousInstance, BoundMethod, \
+    CompiledInstance, AbstractInstanceContext, TreeInstance

jedi/inference/context/decorator.py

@@ -3,7 +3,7 @@ Decorators are not really contexts, however we need some wrappers to improve
 docstrings and other things around decorators.
 '''
 
-from jedi.evaluate.base_context import ContextWrapper
+from jedi.inference.base_context import ContextWrapper
 
 
 class Decoratee(ContextWrapper):

jedi/inference/context/function.py

@@ -2,24 +2,24 @@ from parso.python import tree
 
 from jedi._compatibility import use_metaclass
 from jedi import debug
-from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass
+from jedi.inference.cache import evaluator_method_cache, CachedMetaClass
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate import recursion
+from jedi.inference import recursion
-from jedi.evaluate import docstrings
+from jedi.inference import docstrings
-from jedi.evaluate import flow_analysis
+from jedi.inference import flow_analysis
-from jedi.evaluate import helpers
+from jedi.inference import helpers
-from jedi.evaluate.signature import TreeSignature
+from jedi.inference.signature import TreeSignature
-from jedi.evaluate.arguments import AnonymousArguments
+from jedi.inference.arguments import AnonymousArguments
-from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter
+from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter
-from jedi.evaluate.names import ContextName, AbstractNameDefinition, ParamName
+from jedi.inference.names import ContextName, AbstractNameDefinition, ParamName
-from jedi.evaluate.base_context import ContextualizedNode, NO_CONTEXTS, \
+from jedi.inference.base_context import ContextualizedNode, NO_CONTEXTS, \
     ContextSet, TreeContext, ContextWrapper
-from jedi.evaluate.lazy_context import LazyKnownContexts, LazyKnownContext, \
+from jedi.inference.lazy_context import LazyKnownContexts, LazyKnownContext, \
     LazyTreeContext
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
 from jedi import parser_utils
-from jedi.evaluate.parser_cache import get_yield_exprs
+from jedi.inference.parser_cache import get_yield_exprs
-from jedi.evaluate.helpers import contexts_from_qualified_names
+from jedi.inference.helpers import contexts_from_qualified_names
 
 
 class LambdaName(AbstractNameDefinition):
@@ -70,7 +70,7 @@ class FunctionMixin(object):
                     yield filter
 
     def py__get__(self, instance, class_context):
-        from jedi.evaluate.context.instance import BoundMethod
+        from jedi.inference.context.instance import BoundMethod
         if instance is None:
             # Calling the Foo.bar results in the original bar function.
             return ContextSet([self])
@@ -192,7 +192,7 @@ class FunctionExecutionContext(TreeContext):
             returns = get_yield_exprs(self.evaluator, funcdef)
         else:
             returns = funcdef.iter_return_stmts()
-            from jedi.evaluate.gradual.annotation import infer_return_types
+            from jedi.inference.gradual.annotation import infer_return_types
             context_set = infer_return_types(self)
             if context_set:
                 # If there are annotations, prefer them over anything else.
@@ -326,7 +326,7 @@ class FunctionExecutionContext(TreeContext):
         evaluator = self.evaluator
         is_coroutine = self.tree_node.parent.type in ('async_stmt', 'async_funcdef')
         is_generator = bool(get_yield_exprs(evaluator, self.tree_node))
-        from jedi.evaluate.gradual.typing import GenericClass
+        from jedi.inference.gradual.typing import GenericClass
 
         if is_coroutine:
             if is_generator:

jedi/inference/context/instance.py

@@ -2,22 +2,22 @@ from abc import abstractproperty
 
 from jedi import debug
 from jedi import settings
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.compiled.context import CompiledObjectFilter
+from jedi.inference.compiled.context import CompiledObjectFilter
-from jedi.evaluate.helpers import contexts_from_qualified_names
+from jedi.inference.helpers import contexts_from_qualified_names
-from jedi.evaluate.filters import AbstractFilter
+from jedi.inference.filters import AbstractFilter
-from jedi.evaluate.names import ContextName, TreeNameDefinition
+from jedi.inference.names import ContextName, TreeNameDefinition
-from jedi.evaluate.base_context import Context, NO_CONTEXTS, ContextSet, \
+from jedi.inference.base_context import Context, NO_CONTEXTS, ContextSet, \
     iterator_to_context_set, ContextWrapper
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts
+from jedi.inference.lazy_context import LazyKnownContext, LazyKnownContexts
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.arguments import AnonymousArguments, \
+from jedi.inference.arguments import AnonymousArguments, \
     ValuesArguments, TreeArgumentsWrapper
-from jedi.evaluate.context.function import \
+from jedi.inference.context.function import \
     FunctionContext, FunctionMixin, OverloadedFunctionContext
-from jedi.evaluate.context.klass import ClassContext, apply_py__get__, \
+from jedi.inference.context.klass import ClassContext, apply_py__get__, \
     ClassFilter
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
 from jedi.parser_utils import get_parent_scope
 
 
@@ -39,7 +39,7 @@ class AnonymousInstanceArguments(AnonymousArguments):
         self._instance = instance
 
     def get_executed_params_and_issues(self, execution_context):
-        from jedi.evaluate.dynamic import search_params
+        from jedi.inference.dynamic import search_params
         tree_params = execution_context.tree_node.get_params()
         if not tree_params:
             return [], []
@@ -279,7 +279,7 @@ class TreeInstance(AbstractInstanceContext):
     # to itself.
     @evaluator_method_cache(default=None)
     def _get_annotated_class_object(self):
-        from jedi.evaluate.gradual.annotation import py__annotations__, \
+        from jedi.inference.gradual.annotation import py__annotations__, \
             infer_type_vars_for_execution
 
         for func in self._get_annotation_init_functions():

jedi/inference/context/iterable.py

@@ -25,19 +25,19 @@ import sys
 from jedi import debug
 from jedi import settings
 from jedi._compatibility import force_unicode, is_py3
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate import recursion
+from jedi.inference import recursion
-from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \
+from jedi.inference.lazy_context import LazyKnownContext, LazyKnownContexts, \
     LazyTreeContext
-from jedi.evaluate.helpers import get_int_or_none, is_string, \
+from jedi.inference.helpers import get_int_or_none, is_string, \
-    predefine_names, evaluate_call_of_leaf, reraise_getitem_errors, \
+    predefine_names, infer_call_of_leaf, reraise_getitem_errors, \
     SimpleGetItemNotFound
-from jedi.evaluate.utils import safe_property, to_list
+from jedi.inference.utils import safe_property, to_list
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.filters import ParserTreeFilter, LazyAttributeOverwrite, \
+from jedi.inference.filters import ParserTreeFilter, LazyAttributeOverwrite, \
     publish_method
-from jedi.evaluate.base_context import ContextSet, Context, NO_CONTEXTS, \
+from jedi.inference.base_context import ContextSet, Context, NO_CONTEXTS, \
     TreeContext, ContextualizedNode, iterate_contexts, HelperContextMixin, _sentinel
 from jedi.parser_utils import get_sync_comp_fors
 
@@ -223,7 +223,7 @@ class Sequence(LazyAttributeOverwrite, IterableMixin):
         return (self.merge_types_of_iterate().py__class__(),)
 
     def _get_wrapped_context(self):
-        from jedi.evaluate.gradual.typing import GenericClass
+        from jedi.inference.gradual.typing import GenericClass
         klass = compiled.builtin_from_name(self.evaluator, self.array_type)
         c, = GenericClass(klass, self._get_generics()).execute_annotation()
         return c
@@ -666,7 +666,7 @@ def _check_array_additions(context, sequence):
     >>> a = [""]
     >>> a.append(1)
     """
-    from jedi.evaluate import arguments
+    from jedi.inference import arguments
 
     debug.dbg('Dynamic array search for %s' % sequence, color='MAGENTA')
     module_context = context.get_root_context()
@@ -721,7 +721,7 @@ def _check_array_additions(context, sequence):
 
                 with recursion.execution_allowed(context.evaluator, power) as allowed:
                     if allowed:
-                        found = evaluate_call_of_leaf(
+                        found = infer_call_of_leaf(
                             random_context,
                             name,
                             cut_own_trailer=True
@@ -743,7 +743,7 @@ def _check_array_additions(context, sequence):
 def get_dynamic_array_instance(instance, arguments):
     """Used for set() and list() instances."""
     ai = _ArrayInstance(instance, arguments)
-    from jedi.evaluate import arguments
+    from jedi.inference import arguments
     return arguments.ValuesArguments([ContextSet([ai])])
 
 
@@ -771,7 +771,7 @@ class _ArrayInstance(HelperContextMixin):
             for lazy in lazy_context.infer().iterate():
                 yield lazy
 
-        from jedi.evaluate import arguments
+        from jedi.inference import arguments
         if isinstance(var_args, arguments.TreeArguments):
             additions = _check_array_additions(var_args.context, self.instance)
             for addition in additions:

jedi/inference/context/klass.py

@@ -39,16 +39,16 @@ py__doc__()                            Returns the docstring for a context.
 from jedi import debug
 from jedi._compatibility import use_metaclass
 from jedi.parser_utils import get_cached_parent_scope
-from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass, \
+from jedi.inference.cache import evaluator_method_cache, CachedMetaClass, \
     evaluator_method_generator_cache
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.lazy_context import LazyKnownContexts
+from jedi.inference.lazy_context import LazyKnownContexts
-from jedi.evaluate.filters import ParserTreeFilter
+from jedi.inference.filters import ParserTreeFilter
-from jedi.evaluate.names import TreeNameDefinition, ContextName
+from jedi.inference.names import TreeNameDefinition, ContextName
-from jedi.evaluate.arguments import unpack_arglist, ValuesArguments
+from jedi.inference.arguments import unpack_arglist, ValuesArguments
-from jedi.evaluate.base_context import ContextSet, iterator_to_context_set, \
+from jedi.inference.base_context import ContextSet, iterator_to_context_set, \
     NO_CONTEXTS
-from jedi.evaluate.context.function import FunctionAndClassBase
+from jedi.inference.context.function import FunctionAndClassBase
 from jedi.plugins import plugin_manager
 
 
@@ -71,7 +71,7 @@ class ClassName(TreeNameDefinition):
     @iterator_to_context_set
     def infer(self):
         # We're using a different context to infer, so we cannot call super().
-        from jedi.evaluate.syntax_tree import tree_name_to_contexts
+        from jedi.inference.syntax_tree import tree_name_to_contexts
         inferred = tree_name_to_contexts(
             self.parent_context.evaluator, self._name_context, self.tree_name)
 
@@ -138,7 +138,7 @@ class ClassMixin(object):
         return True
 
     def py__call__(self, arguments=None):
-        from jedi.evaluate.context import TreeInstance
+        from jedi.inference.context import TreeInstance
         if arguments is None:
             arguments = ValuesArguments([])
         return ContextSet([TreeInstance(self.evaluator, self.parent_context, self, arguments)])
@@ -213,7 +213,7 @@ class ClassMixin(object):
                         is_instance=is_instance
                     )
         if not is_instance:
-            from jedi.evaluate.compiled import builtin_from_name
+            from jedi.inference.compiled import builtin_from_name
             type_ = builtin_from_name(self.evaluator, u'type')
             assert isinstance(type_, ClassContext)
             if type_ != self:
@@ -251,7 +251,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
             if stars:
                 continue  # These are not relevant for this search.
 
-            from jedi.evaluate.gradual.annotation import find_unknown_type_vars
+            from jedi.inference.gradual.annotation import find_unknown_type_vars
             for type_var in find_unknown_type_vars(self.parent_context, node):
                 if type_var not in found:
                     # The order matters and it's therefore a list.
@@ -261,7 +261,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
     def _get_bases_arguments(self):
         arglist = self.tree_node.get_super_arglist()
         if arglist:
-            from jedi.evaluate import arguments
+            from jedi.inference import arguments
             return arguments.TreeArguments(self.evaluator, self.parent_context, arglist)
         return None
 
@@ -281,7 +281,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
         )]
 
     def py__getitem__(self, index_context_set, contextualized_node):
-        from jedi.evaluate.gradual.typing import LazyGenericClass
+        from jedi.inference.gradual.typing import LazyGenericClass
         if not index_context_set:
             return ContextSet([self])
         return ContextSet(
@@ -294,7 +294,7 @@ class ClassContext(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBa
         )
 
     def define_generics(self, type_var_dict):
-        from jedi.evaluate.gradual.typing import GenericClass
+        from jedi.inference.gradual.typing import GenericClass
 
         def remap_type_vars():
             """

jedi/inference/context/module.py

@@ -2,15 +2,15 @@ import re
 import os
 
 from jedi import debug
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.names import ContextNameMixin, AbstractNameDefinition
+from jedi.inference.names import ContextNameMixin, AbstractNameDefinition
-from jedi.evaluate.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter
+from jedi.inference.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.base_context import TreeContext
+from jedi.inference.base_context import TreeContext
-from jedi.evaluate.names import SubModuleName
+from jedi.inference.names import SubModuleName
-from jedi.evaluate.helpers import contexts_from_qualified_names
+from jedi.inference.helpers import contexts_from_qualified_names
-from jedi.evaluate.compiled import create_simple_object
+from jedi.inference.compiled import create_simple_object
-from jedi.evaluate.base_context import ContextSet
+from jedi.inference.base_context import ContextSet
 
 
 class _ModuleAttributeName(AbstractNameDefinition):
@@ -160,7 +160,7 @@ class ModuleMixin(SubModuleDictMixin):
     # to push the star imports into Evaluator.module_cache, if we reenable this.
     @evaluator_method_cache([])
     def star_imports(self):
-        from jedi.evaluate.imports import Importer
+        from jedi.inference.imports import Importer
 
         modules = []
         for i in self.tree_node.iter_imports():

jedi/inference/context/namespace.py

@@ -1,8 +1,8 @@
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.filters import DictFilter
+from jedi.inference.filters import DictFilter
-from jedi.evaluate.names import ContextNameMixin, AbstractNameDefinition
+from jedi.inference.names import ContextNameMixin, AbstractNameDefinition
-from jedi.evaluate.base_context import Context
+from jedi.inference.base_context import Context
-from jedi.evaluate.context.module import SubModuleDictMixin
+from jedi.inference.context.module import SubModuleDictMixin
 
 
 class ImplicitNSName(ContextNameMixin, AbstractNameDefinition):

jedi/inference/docstrings.py

@@ -1,6 +1,6 @@
 """
 Docstrings are another source of information for functions and classes.
-:mod:`jedi.evaluate.dynamic` tries to find all executions of functions, while
+:mod:`jedi.inference.dynamic` tries to find all executions of functions, while
 the docstring parsing is much easier. There are three different types of
 docstrings that |jedi| understands:
 
@@ -23,11 +23,11 @@ from parso import parse, ParserSyntaxError
 
 from jedi._compatibility import u
 from jedi import debug
-from jedi.evaluate.utils import indent_block
+from jedi.inference.utils import indent_block
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.base_context import iterator_to_context_set, ContextSet, \
+from jedi.inference.base_context import iterator_to_context_set, ContextSet, \
     NO_CONTEXTS
-from jedi.evaluate.lazy_context import LazyKnownContexts
+from jedi.inference.lazy_context import LazyKnownContexts
 
 
 DOCSTRING_PARAM_PATTERNS = [
@@ -221,7 +221,7 @@ def _evaluate_for_statement_string(module_context, string):
     if stmt.type not in ('name', 'atom', 'atom_expr'):
         return []
 
-    from jedi.evaluate.context import FunctionContext
+    from jedi.inference.context import FunctionContext
     function_context = FunctionContext(
         module_context.evaluator,
         module_context,
@@ -253,7 +253,7 @@ def _execute_array_values(evaluator, 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.
     """
-    from jedi.evaluate.context.iterable import SequenceLiteralContext, FakeSequence
+    from jedi.inference.context.iterable import SequenceLiteralContext, FakeSequence
     if isinstance(array, SequenceLiteralContext):
         values = []
         for lazy_context in array.py__iter__():
@@ -269,8 +269,8 @@ def _execute_array_values(evaluator, array):
 
 @evaluator_method_cache()
 def infer_param(execution_context, param):
-    from jedi.evaluate.context.instance import InstanceArguments
+    from jedi.inference.context.instance import InstanceArguments
-    from jedi.evaluate.context import FunctionExecutionContext
+    from jedi.inference.context import FunctionExecutionContext
 
     def eval_docstring(docstring):
         return ContextSet(

jedi/inference/dynamic.py

@@ -19,16 +19,16 @@ It works as follows:
 
 from jedi import settings
 from jedi import debug
-from jedi.evaluate.cache import evaluator_function_cache
+from jedi.inference.cache import evaluator_function_cache
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate.arguments import TreeArguments
+from jedi.inference.arguments import TreeArguments
-from jedi.evaluate.param import create_default_params
+from jedi.inference.param import create_default_params
-from jedi.evaluate.helpers import is_stdlib_path
+from jedi.inference.helpers import is_stdlib_path
-from jedi.evaluate.utils import to_list
+from jedi.inference.utils import to_list
 from jedi.parser_utils import get_parent_scope
-from jedi.evaluate.context import ModuleContext, instance
+from jedi.inference.context import ModuleContext, instance
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate import recursion
+from jedi.inference import recursion
 
 
 MAX_PARAM_SEARCHES = 20
@@ -103,7 +103,7 @@ def search_params(evaluator, execution_context, funcdef):
                 ))
                 params = [DynamicExecutedParams(evaluator, executed_params)
                           for executed_params in zipped_params]
-                # Evaluate the ExecutedParams to types.
+                # Inferes the ExecutedParams to types.
             else:
                 return create_default_params(execution_context, funcdef)
         finally:
@@ -179,7 +179,7 @@ def _get_possible_nodes(module_context, func_string_name):
 
 
 def _check_name_for_execution(evaluator, context, compare_node, name, trailer):
-    from jedi.evaluate.context.function import FunctionExecutionContext
+    from jedi.inference.context.function import FunctionExecutionContext
 
     def create_func_excs():
         arglist = trailer.children[1]

jedi/inference/filters.py

@@ -8,12 +8,12 @@ import weakref
 from parso.tree import search_ancestor
 
 from jedi._compatibility import use_metaclass
-from jedi.evaluate import flow_analysis
+from jedi.inference import flow_analysis
-from jedi.evaluate.base_context import ContextSet, Context, ContextWrapper, \
+from jedi.inference.base_context import ContextSet, Context, ContextWrapper, \
     LazyContextWrapper
 from jedi.parser_utils import get_cached_parent_scope
-from jedi.evaluate.utils import to_list
+from jedi.inference.utils import to_list
-from jedi.evaluate.names import TreeNameDefinition, ParamName, AbstractNameDefinition
+from jedi.inference.names import TreeNameDefinition, ParamName, AbstractNameDefinition
 
 _definition_name_cache = weakref.WeakKeyDictionary()
 
@@ -394,7 +394,7 @@ def get_global_filters(evaluator, context, until_position, origin_scope):
     >>> list(filters[3].values())  # doctest: +ELLIPSIS
     [...]
     """
-    from jedi.evaluate.context.function import FunctionExecutionContext
+    from jedi.inference.context.function import FunctionExecutionContext
     while context is not None:
         # Names in methods cannot be resolved within the class.
         for filter in context.get_filters(

jedi/inference/finder.py

@@ -19,17 +19,17 @@ from parso.python import tree
 from parso.tree import search_ancestor
 from jedi import debug
 from jedi import settings
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate import flow_analysis
+from jedi.inference import flow_analysis
-from jedi.evaluate.arguments import TreeArguments
+from jedi.inference.arguments import TreeArguments
-from jedi.evaluate import helpers
+from jedi.inference import helpers
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
-from jedi.evaluate.filters import get_global_filters
+from jedi.inference.filters import get_global_filters
-from jedi.evaluate.names import TreeNameDefinition
+from jedi.inference.names import TreeNameDefinition
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
 from jedi.parser_utils import is_scope, get_parent_scope
-from jedi.evaluate.gradual.conversion import convert_contexts
+from jedi.inference.gradual.conversion import convert_contexts
 
 
 class NameFinder(object):

jedi/inference/flow_analysis.py

@@ -1,5 +1,5 @@
 from jedi.parser_utils import get_flow_branch_keyword, is_scope, get_parent_scope
-from jedi.evaluate.recursion import execution_allowed
+from jedi.inference.recursion import execution_allowed
 
 
 class Status(object):

jedi/inference/gradual/annotation.py

@@ -10,20 +10,20 @@ import re
 from parso import ParserSyntaxError, parse
 
 from jedi._compatibility import force_unicode
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.typing import TypeVar, LazyGenericClass, \
+from jedi.inference.gradual.typing import TypeVar, LazyGenericClass, \
     AbstractAnnotatedClass
-from jedi.evaluate.gradual.typing import GenericClass
+from jedi.inference.gradual.typing import GenericClass
-from jedi.evaluate.helpers import is_string
+from jedi.inference.helpers import is_string
-from jedi.evaluate.compiled import builtin_from_name
+from jedi.inference.compiled import builtin_from_name
 from jedi import debug
 from jedi import parser_utils
 
 
 def eval_annotation(context, annotation):
     """
-    Evaluates an annotation node. This means that it evaluates the part of
+    Inferes an annotation node. This means that it inferes the part of
     `int` here:
 
         foo: int = 3
@@ -158,7 +158,7 @@ def _infer_param(execution_context, param):
                 "Comments length != Params length %s %s",
                 params_comments, all_params
             )
-        from jedi.evaluate.context.instance import InstanceArguments
+        from jedi.inference.context.instance import InstanceArguments
         if isinstance(execution_context.var_args, InstanceArguments):
             if index == 0:
                 # Assume it's self, which is already handled

jedi/inference/gradual/conversion.py

@@ -1,8 +1,8 @@
 from jedi import debug
-from jedi.evaluate.base_context import ContextSet, \
+from jedi.inference.base_context import ContextSet, \
     NO_CONTEXTS
-from jedi.evaluate.utils import to_list
+from jedi.inference.utils import to_list
-from jedi.evaluate.gradual.stub_context import StubModuleContext
+from jedi.inference.gradual.stub_context import StubModuleContext
 
 
 def _stub_to_python_context_set(stub_context, ignore_compiled=False):
@@ -40,7 +40,7 @@ def _stub_to_python_context_set(stub_context, ignore_compiled=False):
 
 
 def _infer_from_stub(stub_module, qualified_names, ignore_compiled):
-    from jedi.evaluate.compiled.mixed import MixedObject
+    from jedi.inference.compiled.mixed import MixedObject
     assert isinstance(stub_module, (StubModuleContext, MixedObject)), stub_module
     non_stubs = stub_module.non_stub_context_set
     if ignore_compiled:
@@ -85,7 +85,7 @@ def _try_stub_to_python_names(names, prefer_stub_to_compiled=False):
 def _load_stub_module(module):
     if module.is_stub():
         return module
-    from jedi.evaluate.gradual.typeshed import _try_to_load_stub_cached
+    from jedi.inference.gradual.typeshed import _try_to_load_stub_cached
     return _try_to_load_stub_cached(
         module.evaluator,
         import_names=module.string_names,

jedi/inference/gradual/stub_context.py

@@ -1,8 +1,8 @@
-from jedi.evaluate.base_context import ContextWrapper
+from jedi.inference.base_context import ContextWrapper
-from jedi.evaluate.context.module import ModuleContext
+from jedi.inference.context.module import ModuleContext
-from jedi.evaluate.filters import ParserTreeFilter, \
+from jedi.inference.filters import ParserTreeFilter, \
     TreeNameDefinition
-from jedi.evaluate.gradual.typing import TypingModuleFilterWrapper
+from jedi.inference.gradual.typing import TypingModuleFilterWrapper
 
 
 class StubModuleContext(ModuleContext):

jedi/inference/gradual/typeshed.py

@@ -5,8 +5,8 @@ from functools import wraps
 from jedi.file_io import FileIO
 from jedi._compatibility import FileNotFoundError, cast_path
 from jedi.parser_utils import get_cached_code_lines
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.stub_context import TypingModuleWrapper, StubModuleContext
+from jedi.inference.gradual.stub_context import TypingModuleWrapper, StubModuleContext
 
 _jedi_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 TYPESHED_PATH = os.path.join(_jedi_path, 'third_party', 'typeshed')

jedi/inference/gradual/typing.py

@@ -7,19 +7,19 @@ This file deals with all the typing.py cases.
 """
 from jedi._compatibility import unicode, force_unicode
 from jedi import debug
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.compiled import builtin_from_name
+from jedi.inference.compiled import builtin_from_name
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, Context, \
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS, Context, \
     iterator_to_context_set, ContextWrapper, LazyContextWrapper
-from jedi.evaluate.lazy_context import LazyKnownContexts
+from jedi.inference.lazy_context import LazyKnownContexts
-from jedi.evaluate.context.iterable import SequenceLiteralContext
+from jedi.inference.context.iterable import SequenceLiteralContext
-from jedi.evaluate.arguments import repack_with_argument_clinic
+from jedi.inference.arguments import repack_with_argument_clinic
-from jedi.evaluate.utils import to_list
+from jedi.inference.utils import to_list
-from jedi.evaluate.filters import FilterWrapper
+from jedi.inference.filters import FilterWrapper
-from jedi.evaluate.names import NameWrapper, AbstractTreeName, \
+from jedi.inference.names import NameWrapper, AbstractTreeName, \
     AbstractNameDefinition, ContextName
-from jedi.evaluate.helpers import is_string
+from jedi.inference.helpers import is_string
-from jedi.evaluate.context.klass import ClassMixin, ClassFilter
+from jedi.inference.context.klass import ClassMixin, ClassFilter
 
 _PROXY_CLASS_TYPES = 'Tuple Generic Protocol Callable Type'.split()
 _TYPE_ALIAS_TYPES = {
@@ -232,7 +232,7 @@ def _iter_over_arguments(maybe_tuple_context, defining_context):
     def resolve_forward_references(context_set):
         for context in context_set:
             if is_string(context):
-                from jedi.evaluate.gradual.annotation import _get_forward_reference_node
+                from jedi.inference.gradual.annotation import _get_forward_reference_node
                 node = _get_forward_reference_node(defining_context, context.get_safe_value())
                 if node is not None:
                     for c in defining_context.eval_node(node):
@@ -267,7 +267,7 @@ class TypeAlias(LazyContextWrapper):
             module_name = '__builtin__'
 
         # TODO use evaluator.import_module?
-        from jedi.evaluate.imports import Importer
+        from jedi.inference.imports import Importer
         module, = Importer(
             self.evaluator, [module_name], self.evaluator.builtins_module
         ).follow()

jedi/inference/gradual/utils.py

@@ -1,6 +1,6 @@
 import os
 
-from jedi.evaluate.gradual.typeshed import TYPESHED_PATH, create_stub_module
+from jedi.inference.gradual.typeshed import TYPESHED_PATH, create_stub_module
 
 
 def load_proper_stub_module(evaluator, file_io, import_names, module_node):

jedi/inference/helpers.py

@@ -44,7 +44,7 @@ def deep_ast_copy(obj):
     return new_obj
 
 
-def evaluate_call_of_leaf(context, leaf, cut_own_trailer=False):
+def infer_call_of_leaf(context, leaf, cut_own_trailer=False):
     """
     Creates a "call" node that consist of all ``trailer`` and ``power``
     objects.  E.g. if you call it with ``append``::
@@ -65,7 +65,7 @@ def evaluate_call_of_leaf(context, leaf, cut_own_trailer=False):
     """
     trailer = leaf.parent
     if trailer.type == 'fstring':
-        from jedi.evaluate import compiled
+        from jedi.inference import compiled
         return compiled.get_string_context_set(context.evaluator)
 
     # The leaf may not be the last or first child, because there exist three
@@ -100,7 +100,7 @@ def evaluate_call_of_leaf(context, leaf, cut_own_trailer=False):
         trailers = trailers[1:]
 
     values = context.eval_node(base)
-    from jedi.evaluate.syntax_tree import eval_trailer
+    from jedi.inference.syntax_tree import eval_trailer
     for trailer in trailers:
         values = eval_trailer(context, values, trailer)
     return values

jedi/inference/imports.py

@@ -1,5 +1,5 @@
 """
-:mod:`jedi.evaluate.imports` is here to resolve import statements and return
+:mod:`jedi.inference.imports` is here to resolve import statements and return
 the modules/classes/functions/whatever, which they stand for. However there's
 not any actual importing done. This module is about finding modules in the
 filesystem. This can be quite tricky sometimes, because Python imports are not
@@ -23,16 +23,16 @@ from jedi import debug
 from jedi import settings
 from jedi.file_io import KnownContentFileIO, FileIO
 from jedi.parser_utils import get_cached_code_lines
-from jedi.evaluate import sys_path
+from jedi.inference import sys_path
-from jedi.evaluate import helpers
+from jedi.inference import helpers
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate.utils import unite
+from jedi.inference.utils import unite
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.names import ImportName, SubModuleName
+from jedi.inference.names import ImportName, SubModuleName
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
-from jedi.evaluate.gradual.typeshed import import_module_decorator
+from jedi.inference.gradual.typeshed import import_module_decorator
-from jedi.evaluate.context.module import iter_module_names
+from jedi.inference.context.module import iter_module_names
 from jedi.plugins import plugin_manager
 
 
@@ -202,7 +202,7 @@ class Importer(object):
         self.module_context = module_context
 
         self._fixed_sys_path = None
-        self._inference_possible = True
+        self._infer_possible = True
         if level:
             base = module_context.py__package__()
             # We need to care for two cases, the first one is if it's a valid
@@ -238,7 +238,7 @@ class Importer(object):
                 if base_directory is None:
                     # Everything is lost, the relative import does point
                     # somewhere out of the filesystem.
-                    self._inference_possible = False
+                    self._infer_possible = False
                 else:
                     self._fixed_sys_path = [force_unicode(base_directory)]
 
@@ -278,7 +278,7 @@ class Importer(object):
         return sys_path_mod
 
     def follow(self):
-        if not self.import_path or not self._inference_possible:
+        if not self.import_path or not self._infer_possible:
             return NO_CONTEXTS
 
         import_names = tuple(
@@ -329,7 +329,7 @@ class Importer(object):
         :param only_modules: Indicates wheter it's possible to import a
             definition that is not defined in a module.
         """
-        if not self._inference_possible:
+        if not self._infer_possible:
             return []
 
         names = []
@@ -356,7 +356,7 @@ class Importer(object):
                 names += context.sub_modules_dict().values()
 
             if not only_modules:
-                from jedi.evaluate.gradual.conversion import convert_contexts
+                from jedi.inference.gradual.conversion import convert_contexts
 
                 both_contexts = contexts | convert_contexts(contexts)
                 for c in both_contexts:
@@ -421,7 +421,7 @@ def import_module(evaluator, import_names, parent_module_context, sys_path):
                 return NO_CONTEXTS
 
     if isinstance(file_io_or_ns, ImplicitNSInfo):
-        from jedi.evaluate.context.namespace import ImplicitNamespaceContext
+        from jedi.inference.context.namespace import ImplicitNamespaceContext
         module = ImplicitNamespaceContext(
             evaluator,
             fullname=file_io_or_ns.name,
@@ -459,7 +459,7 @@ def _load_python_module(evaluator, file_io, sys_path=None,
         cache_path=settings.cache_directory
     )
 
-    from jedi.evaluate.context import ModuleContext
+    from jedi.inference.context import ModuleContext
     return ModuleContext(
         evaluator, module_node,
         file_io=file_io,

jedi/inference/lazy_context.py

@@ -1,4 +1,4 @@
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
 from jedi.common.utils import monkeypatch
 
 

jedi/inference/names.py

@@ -3,7 +3,7 @@ from abc import abstractmethod
 from parso.tree import search_ancestor
 
 from jedi._compatibility import Parameter
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS
 from jedi.cache import memoize_method
 
 
@@ -155,7 +155,7 @@ class TreeNameDefinition(AbstractTreeName):
 
     def infer(self):
         # Refactor this, should probably be here.
-        from jedi.evaluate.syntax_tree import tree_name_to_contexts
+        from jedi.inference.syntax_tree import tree_name_to_contexts
         parent = self.parent_context
         return tree_name_to_contexts(parent.evaluator, parent, self.tree_name)
 
@@ -344,7 +344,7 @@ class ImportName(AbstractNameDefinition):
 
     @memoize_method
     def infer(self):
-        from jedi.evaluate.imports import Importer
+        from jedi.inference.imports import Importer
         m = self._from_module_context
         return Importer(m.evaluator, [self.string_name], m, level=self._level).follow()
 

jedi/inference/param.py

@@ -1,12 +1,12 @@
 from collections import defaultdict
 
 from jedi import debug
-from jedi.evaluate.utils import PushBackIterator
+from jedi.inference.utils import PushBackIterator
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate.lazy_context import LazyKnownContext, \
+from jedi.inference.lazy_context import LazyKnownContext, \
     LazyTreeContext, LazyUnknownContext
-from jedi.evaluate import docstrings
+from jedi.inference import docstrings
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
 
 
 def _add_argument_issue(error_name, lazy_context, message):
@@ -27,7 +27,7 @@ class ExecutedParam(object):
         self._is_default = is_default
 
     def infer_annotations(self):
-        from jedi.evaluate.gradual.annotation import infer_param
+        from jedi.inference.gradual.annotation import infer_param
         return infer_param(self._execution_context, self._param_node)
 
     def infer(self, use_hints=True):

jedi/inference/parser_cache.py

@@ -1,4 +1,4 @@
-from jedi.evaluate.cache import evaluator_function_cache
+from jedi.inference.cache import evaluator_function_cache
 
 
 @evaluator_function_cache()

jedi/inference/recursion.py

@@ -3,7 +3,7 @@ Recursions are the recipe of |jedi| to conquer Python code. However, someone
 must stop recursions going mad. Some settings are here to make |jedi| stop at
 the right time. You can read more about them :ref:`here <settings-recursion>`.
 
-Next to :mod:`jedi.evaluate.cache` this module also makes |jedi| not
+Next to :mod:`jedi.inference.cache` this module also makes |jedi| not
 thread-safe. Why?  ``execution_recursion_decorator`` uses class variables to
 count the function calls.
 
@@ -29,7 +29,7 @@ therefore the quality might not always be maximal.
 from contextlib import contextmanager
 
 from jedi import debug
-from jedi.evaluate.base_context import NO_CONTEXTS
+from jedi.inference.base_context import NO_CONTEXTS
 
 
 recursion_limit = 15

jedi/inference/signature.py

@@ -85,7 +85,7 @@ class TreeSignature(AbstractSignature):
     def get_param_names(self, resolve_stars=False):
         params = super(TreeSignature, self).get_param_names(resolve_stars=False)
         if resolve_stars:
-            from jedi.evaluate.star_args import process_params
+            from jedi.inference.star_args import process_params
             params = process_params(params)
         return params
 

jedi/inference/star_args.py

@@ -12,13 +12,13 @@ The signature here for bar should be `bar(b, c)` instead of bar(*args).
 """
 
 from jedi._compatibility import Parameter
-from jedi.evaluate.utils import to_list
+from jedi.inference.utils import to_list
-from jedi.evaluate.names import ParamNameWrapper
+from jedi.inference.names import ParamNameWrapper
 
 
 def _iter_nodes_for_param(param_name):
     from parso.python.tree import search_ancestor
-    from jedi.evaluate.arguments import TreeArguments
+    from jedi.inference.arguments import TreeArguments
 
     execution_context = param_name.parent_context
     function_node = execution_context.tree_node
@@ -54,7 +54,7 @@ def _iter_nodes_for_param(param_name):
 def _goes_to_param_name(param_name, context, potential_name):
     if potential_name.type != 'name':
         return False
-    from jedi.evaluate.names import TreeNameDefinition
+    from jedi.inference.names import TreeNameDefinition
     found = TreeNameDefinition(context, potential_name).goto()
     return any(param_name.parent_context == p.parent_context
                and param_name.start_pos == p.start_pos
@@ -62,7 +62,7 @@ def _goes_to_param_name(param_name, context, potential_name):
 
 
 def _to_callables(context, trailer):
-    from jedi.evaluate.syntax_tree import eval_trailer
+    from jedi.inference.syntax_tree import eval_trailer
 
     atom_expr = trailer.parent
     index = atom_expr.children[0] == 'await'

jedi/inference/syntax_tree.py

@@ -8,25 +8,25 @@ from parso.python import tree
 from jedi._compatibility import force_unicode, unicode
 from jedi import debug
 from jedi import parser_utils
-from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, ContextualizedNode, \
+from jedi.inference.base_context import ContextSet, NO_CONTEXTS, ContextualizedNode, \
     ContextualizedName, iterator_to_context_set, iterate_contexts
-from jedi.evaluate.lazy_context import LazyTreeContext
+from jedi.inference.lazy_context import LazyTreeContext
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate import recursion
+from jedi.inference import recursion
-from jedi.evaluate import helpers
+from jedi.inference import helpers
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate import arguments
+from jedi.inference import arguments
-from jedi.evaluate.context import ClassContext, FunctionContext
+from jedi.inference.context import ClassContext, FunctionContext
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
-from jedi.evaluate.context import TreeInstance
+from jedi.inference.context import TreeInstance
-from jedi.evaluate.finder import NameFinder
+from jedi.inference.finder import NameFinder
-from jedi.evaluate.helpers import is_string, is_literal, is_number
+from jedi.inference.helpers import is_string, is_literal, is_number
-from jedi.evaluate.compiled.access import COMPARISON_OPERATORS
+from jedi.inference.compiled.access import COMPARISON_OPERATORS
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.gradual.stub_context import VersionInfo
+from jedi.inference.gradual.stub_context import VersionInfo
-from jedi.evaluate.gradual import annotation
+from jedi.inference.gradual import annotation
-from jedi.evaluate.context.decorator import Decoratee
+from jedi.inference.context.decorator import Decoratee
 from jedi.plugins import plugin_manager
 
 
@@ -215,7 +215,7 @@ def eval_atom(context, atom):
             # Contrary to yield from, yield can just appear alone to return a
             # value when used with `.send()`.
             return NO_CONTEXTS
-        assert False, 'Cannot evaluate the keyword %s' % atom
+        assert False, 'Cannot infer the keyword %s' % atom
 
     elif isinstance(atom, tree.Literal):
         string = context.evaluator.compiled_subprocess.safe_literal_eval(atom.value)
@@ -649,7 +649,7 @@ def _apply_decorators(context, node):
             dec_values = context.eval_node(dec.children[1])
             trailer_nodes = dec.children[2:-1]
             if trailer_nodes:
-                # Create a trailer and evaluate it.
+                # Create a trailer and infer it.
                 trailer = tree.PythonNode('trailer', trailer_nodes)
                 trailer.parent = dec
                 dec_values = eval_trailer(context, dec_values, trailer)

jedi/inference/sys_path.py

@@ -1,9 +1,9 @@
 import os
 
 from jedi._compatibility import unicode, force_unicode, all_suffixes
-from jedi.evaluate.cache import evaluator_method_cache
+from jedi.inference.cache import evaluator_method_cache
-from jedi.evaluate.base_context import ContextualizedNode
+from jedi.inference.base_context import ContextualizedNode
-from jedi.evaluate.helpers import is_string
+from jedi.inference.helpers import is_string
 from jedi.common.utils import traverse_parents
 from jedi.parser_utils import get_cached_code_lines
 from jedi.file_io import FileIO
@@ -152,7 +152,7 @@ def _get_paths_from_buildout_script(evaluator, buildout_script_path):
         debug.warning('Error trying to read buildout_script: %s', buildout_script_path)
         return
 
-    from jedi.evaluate.context import ModuleContext
+    from jedi.inference.context import ModuleContext
     module = ModuleContext(
         evaluator, module_node, file_io,
         string_names=None,

jedi/inference/usages.py

@@ -1,5 +1,5 @@
-from jedi.evaluate import imports
+from jedi.inference import imports
-from jedi.evaluate.names import TreeNameDefinition
+from jedi.inference.names import TreeNameDefinition
 
 
 def _resolve_names(definition_names, avoid_names=()):

jedi/plugins/stdlib.py

@@ -14,27 +14,27 @@ import os
 
 from jedi._compatibility import force_unicode, Parameter
 from jedi import debug
-from jedi.evaluate.utils import safe_property
+from jedi.inference.utils import safe_property
-from jedi.evaluate.helpers import get_str_or_none
+from jedi.inference.helpers import get_str_or_none
-from jedi.evaluate.arguments import ValuesArguments, \
+from jedi.inference.arguments import ValuesArguments, \
     repack_with_argument_clinic, AbstractArguments, TreeArgumentsWrapper
-from jedi.evaluate import analysis
+from jedi.inference import analysis
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.context.instance import BoundMethod, InstanceArguments
+from jedi.inference.context.instance import BoundMethod, InstanceArguments
-from jedi.evaluate.base_context import ContextualizedNode, \
+from jedi.inference.base_context import ContextualizedNode, \
     NO_CONTEXTS, ContextSet, ContextWrapper, LazyContextWrapper
-from jedi.evaluate.context import ClassContext, ModuleContext, \
+from jedi.inference.context import ClassContext, ModuleContext, \
     FunctionExecutionContext
-from jedi.evaluate.context.klass import ClassMixin
+from jedi.inference.context.klass import ClassMixin
-from jedi.evaluate.context.function import FunctionMixin
+from jedi.inference.context.function import FunctionMixin
-from jedi.evaluate.context import iterable
+from jedi.inference.context import iterable
-from jedi.evaluate.lazy_context import LazyTreeContext, LazyKnownContext, \
+from jedi.inference.lazy_context import LazyTreeContext, LazyKnownContext, \
     LazyKnownContexts
-from jedi.evaluate.names import ContextName, BaseTreeParamName
+from jedi.inference.names import ContextName, BaseTreeParamName
-from jedi.evaluate.syntax_tree import is_string
+from jedi.inference.syntax_tree import is_string
-from jedi.evaluate.filters import AttributeOverwrite, publish_method, \
+from jedi.inference.filters import AttributeOverwrite, publish_method, \
     ParserTreeFilter, DictFilter
-from jedi.evaluate.signature import AbstractSignature, SignatureWrapper
+from jedi.inference.signature import AbstractSignature, SignatureWrapper
 
 
 # Copied from Python 3.6's stdlib.

jedi/refactoring.py

@@ -18,7 +18,7 @@ following functions (sometimes bug-prone):
 import difflib
 
 from parso import python_bytes_to_unicode, split_lines
-from jedi.evaluate import helpers
+from jedi.inference import helpers
 
 
 class Refactoring(object):

test/completion/generators.py

@@ -24,7 +24,7 @@ next(gen_ret(1))
 #? []
 next(gen_ret()).
 
-# generators evaluate to true if cast by bool.
+# generators infer to true if cast by bool.
 a = ''
 if gen_ret():
     a = 3

test/completion/sys_path.py

@@ -10,11 +10,11 @@ sys.path.append(dirname(os.path.abspath('thirdparty' + os.path.sep + 'asdf')))
 # syntax err
 sys.path.append('a' +* '/thirdparty')
 
-#? ['evaluate']
+#? ['inference']
-import evaluate
+import inference
 
 #? ['evaluator_function_cache']
-evaluate.Evaluator_fu
+inference.Evaluator_fu
 
 # Those don't work because dirname and abspath are not properly understood.
 ##? ['jedi_']

test/completion/thirdparty/jedi_.py

@@ -1,5 +1,5 @@
 
-from jedi import functions, evaluate, parsing
+from jedi import functions, inference, parsing
 
 el = functions.completions()[0]
 #? ['description']
@@ -18,17 +18,17 @@ el = scopes
 
 # get_names_for_scope is also recursion stuff
 #? tuple()
-el = list(evaluate.get_names_for_scope())[0]
+el = list(inference.get_names_for_scope())[0]
 
 #? int() parsing.Module()
-el = list(evaluate.get_names_for_scope(1))[0][0]
+el = list(inference.get_names_for_scope(1))[0][0]
 #? parsing.Module()
-el = list(evaluate.get_names_for_scope())[0][0]
+el = list(inference.get_names_for_scope())[0][0]
 
 #? list()
-el = list(evaluate.get_names_for_scope(1))[0][1]
+el = list(inference.get_names_for_scope(1))[0][1]
 #? list()
-el = list(evaluate.get_names_for_scope())[0][1]
+el = list(inference.get_names_for_scope())[0][1]
 
 #? list()
 parsing.Scope((0,0)).get_set_vars()
@@ -39,14 +39,14 @@ parsing.Scope((0,0)).get_set_vars()[0]
 parsing.Scope((0,0)).get_set_vars()[0].parent
 
 #? parsing.Import() parsing.Name()
-el = list(evaluate.get_names_for_scope())[0][1][0]
+el = list(inference.get_names_for_scope())[0][1][0]
 
-#? evaluate.Array() evaluate.Class() evaluate.Function() evaluate.Instance()
+#? inference.Array() inference.Class() inference.Function() inference.Instance()
-list(evaluate.follow_call())[0]
+list(inference.follow_call())[0]
 
 # With the right recursion settings, this should be possible (and maybe more):
 # Array Class Function Generator Instance Module
 # However, this was produced with the recursion settings 10/350/10000, and
 # lasted 18.5 seconds. So we just have to be content with the results.
-#? evaluate.Class() evaluate.Function()
+#? inference.Class() inference.Function()
-evaluate.get_scopes_for_name()[0]
+inference.get_scopes_for_name()[0]

test/conftest.py

@@ -10,7 +10,7 @@ from . import refactor
 
 import jedi
 from jedi.api.environment import InterpreterEnvironment
-from jedi.evaluate.analysis import Warning
+from jedi.inference.analysis import Warning
 
 
 def pytest_addoption(parser):

test/run.py

@@ -126,7 +126,7 @@ from jedi.api.classes import Definition
 from jedi.api.completion import get_user_scope
 from jedi import parser_utils
 from jedi.api.environment import get_default_environment, get_system_environment
-from jedi.evaluate.gradual.conversion import convert_contexts
+from jedi.inference.gradual.conversion import convert_contexts
 
 
 TEST_COMPLETIONS = 0

test/test_api/test_api.py

@@ -9,7 +9,7 @@ from pytest import raises
 from parso import cache
 
 from jedi import preload_module
-from jedi.evaluate.gradual import typeshed
+from jedi.inference.gradual import typeshed
 
 
 def test_preload_modules():

test/test_api/test_classes.py

@@ -8,7 +8,7 @@ import pytest
 
 import jedi
 from jedi import __doc__ as jedi_doc
-from jedi.evaluate.compiled import CompiledContextName
+from jedi.inference.compiled import CompiledContextName
 
 
 def test_is_keyword(Script):

test/test_api/test_completion.py

@@ -89,7 +89,7 @@ def test_fake_subnodes(Script):
     Test the number of subnodes of a fake object.
 
     There was a bug where the number of child nodes would grow on every
-    call to :func:``jedi.evaluate.compiled.fake.get_faked``.
+    call to :func:``jedi.inference.compiled.fake.get_faked``.
 
     See Github PR#649 and isseu #591.
     """

test/test_api/test_interpreter.py

@@ -7,7 +7,7 @@ import pytest
 
 import jedi
 from jedi._compatibility import is_py3, py_version
-from jedi.evaluate.compiled import mixed, context
+from jedi.inference.compiled import mixed, context
 from importlib import import_module
 
 if py_version > 30:

test/test_api/test_settings.py

@@ -3,7 +3,7 @@ import os
 import pytest
 
 from jedi import api
-from jedi.evaluate import imports
+from jedi.inference import imports
 from ..helpers import cwd_at
 
 

test/test_inference/test_buildout_detection.py

@@ -2,7 +2,7 @@ import os
 from textwrap import dedent
 
 from jedi._compatibility import force_unicode
-from jedi.evaluate.sys_path import (_get_parent_dir_with_file,
+from jedi.inference.sys_path import (_get_parent_dir_with_file,
                                     _get_buildout_script_paths,
                                     check_sys_path_modifications)
 

test/test_inference/test_compiled.py

@@ -6,9 +6,9 @@ from datetime import datetime
 
 import pytest
 
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate.compiled.access import DirectObjectAccess
+from jedi.inference.compiled.access import DirectObjectAccess
-from jedi.evaluate.gradual.conversion import _stub_to_python_context_set
+from jedi.inference.gradual.conversion import _stub_to_python_context_set
 
 
 def test_simple(evaluator, environment):

test/test_inference/test_gradual/test_typeshed.py

@@ -3,8 +3,8 @@ import os
 import pytest
 from parso.utils import PythonVersionInfo
 
-from jedi.evaluate.gradual import typeshed, stub_context
+from jedi.inference.gradual import typeshed, stub_context
-from jedi.evaluate.context import TreeInstance, BoundMethod, FunctionContext, \
+from jedi.inference.context import TreeInstance, BoundMethod, FunctionContext, \
     MethodContext, ClassContext
 
 TYPESHED_PYTHON3 = os.path.join(typeshed.TYPESHED_PATH, 'stdlib', '3')

test/test_inference/test_helpers.py

@@ -1,7 +1,7 @@
 from textwrap import dedent
 
 from jedi import names
-from jedi.evaluate import helpers
+from jedi.inference import helpers
 
 
 def test_call_of_leaf_in_brackets(environment):

test/test_inference/test_imports.py

@@ -9,10 +9,10 @@ import pytest
 from jedi.file_io import FileIO, KnownContentFileIO
 
 from jedi._compatibility import find_module_py33, find_module
-from jedi.evaluate import compiled
+from jedi.inference import compiled
-from jedi.evaluate import imports
+from jedi.inference import imports
 from jedi.api.project import Project
-from jedi.evaluate.gradual.conversion import _stub_to_python_context_set
+from jedi.inference.gradual.conversion import _stub_to_python_context_set
 from ..helpers import cwd_at, get_example_dir, test_dir, root_dir
 
 THIS_DIR = os.path.dirname(__file__)

test/test_inference/test_literals.py

@@ -1,5 +1,5 @@
 import pytest
-from jedi.evaluate.context import TreeInstance
+from jedi.inference.context import TreeInstance
 
 
 def _eval_literal(Script, code, is_fstring=False):

test/test_inference/test_precedence.py

@@ -1,4 +1,4 @@
-from jedi.evaluate.compiled import CompiledObject
+from jedi.inference.compiled import CompiledObject
 
 import pytest
 

test/test_inference/test_signature.py

@@ -4,7 +4,7 @@ import re
 
 import pytest
 
-from jedi.evaluate.gradual.conversion import _stub_to_python_context_set
+from jedi.inference.gradual.conversion import _stub_to_python_context_set
 
 
 @pytest.mark.parametrize(

test/test_inference/test_sys_path.py

@@ -6,7 +6,7 @@ import shutil
 import pytest
 from ..helpers import skip_if_windows, skip_if_not_windows
 
-from jedi.evaluate import sys_path
+from jedi.inference import sys_path
 from jedi.api.environment import create_environment
 
 

test/test_settings.py

@@ -1,9 +1,9 @@
 import pytest
 
 from jedi import settings
-from jedi.evaluate.names import ContextName
+from jedi.inference.names import ContextName
-from jedi.evaluate.compiled import CompiledContextName
+from jedi.inference.compiled import CompiledContextName
-from jedi.evaluate.gradual.typeshed import StubModuleContext
+from jedi.inference.gradual.typeshed import StubModuleContext
 
 
 @pytest.fixture()