From 3b4f2924648eafb9660caac9030b20beb50a83bb Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Thu, 15 Aug 2019 00:12:11 +0200 Subject: [PATCH] Move the evaluate package to inference --- .coveragerc | 2 +- conftest.py | 2 +- docs/docs/development.rst | 52 +++++++++---------- jedi/api/__init__.py | 32 ++++++------ jedi/api/classes.py | 16 +++--- jedi/api/completion.py | 10 ++-- jedi/api/environment.py | 2 +- jedi/api/file_name.py | 4 +- jedi/api/helpers.py | 14 ++--- jedi/api/interpreter.py | 10 ++-- jedi/api/keywords.py | 4 +- jedi/api/project.py | 4 +- jedi/evaluate/context/__init__.py | 6 --- jedi/{evaluate => inference}/__init__.py | 40 +++++++------- jedi/{evaluate => inference}/analysis.py | 8 +-- jedi/{evaluate => inference}/arguments.py | 24 ++++----- jedi/{evaluate => inference}/base_context.py | 24 ++++----- jedi/{evaluate => inference}/cache.py | 0 .../compiled/__init__.py | 4 +- .../compiled/access.py | 2 +- .../compiled/context.py | 26 +++++----- .../compiled/getattr_static.py | 0 .../{evaluate => inference}/compiled/mixed.py | 18 +++---- .../compiled/subprocess/__init__.py | 6 +-- .../compiled/subprocess/__main__.py | 4 +- .../compiled/subprocess/functions.py | 2 +- jedi/inference/context/__init__.py | 6 +++ .../context/decorator.py | 2 +- .../context/function.py | 36 ++++++------- .../context/instance.py | 28 +++++----- .../context/iterable.py | 30 +++++------ jedi/{evaluate => inference}/context/klass.py | 30 +++++------ .../{evaluate => inference}/context/module.py | 20 +++---- .../context/namespace.py | 10 ++-- jedi/{evaluate => inference}/docstrings.py | 18 +++---- jedi/{evaluate => inference}/dynamic.py | 22 ++++---- jedi/{evaluate => inference}/filters.py | 10 ++-- jedi/{evaluate => inference}/finder.py | 20 +++---- jedi/{evaluate => inference}/flow_analysis.py | 2 +- .../gradual/__init__.py | 0 .../gradual/annotation.py | 16 +++--- .../gradual/conversion.py | 10 ++-- .../gradual/stub_context.py | 8 +-- .../gradual/typeshed.py | 4 +- .../{evaluate => inference}/gradual/typing.py | 26 +++++----- jedi/{evaluate => inference}/gradual/utils.py | 2 +- jedi/{evaluate => inference}/helpers.py | 6 +-- jedi/{evaluate => inference}/imports.py | 36 ++++++------- jedi/{evaluate => inference}/lazy_context.py | 2 +- jedi/{evaluate => inference}/names.py | 6 +-- jedi/{evaluate => inference}/param.py | 12 ++--- jedi/{evaluate => inference}/parser_cache.py | 2 +- jedi/{evaluate => inference}/recursion.py | 4 +- jedi/{evaluate => inference}/signature.py | 2 +- jedi/{evaluate => inference}/star_args.py | 10 ++-- jedi/{evaluate => inference}/syntax_tree.py | 40 +++++++------- jedi/{evaluate => inference}/sys_path.py | 8 +-- jedi/{evaluate => inference}/usages.py | 4 +- jedi/{evaluate => inference}/utils.py | 0 jedi/plugins/stdlib.py | 32 ++++++------ jedi/refactoring.py | 2 +- test/completion/generators.py | 2 +- test/completion/sys_path.py | 6 +-- test/completion/thirdparty/jedi_.py | 22 ++++---- test/conftest.py | 2 +- test/run.py | 2 +- test/test_api/test_api.py | 2 +- test/test_api/test_classes.py | 2 +- test/test_api/test_completion.py | 2 +- test/test_api/test_interpreter.py | 2 +- test/test_api/test_settings.py | 2 +- .../test_inference/test_buildout_detection.py | 2 +- test/test_inference/test_compiled.py | 6 +-- .../test_gradual/test_typeshed.py | 4 +- test/test_inference/test_helpers.py | 2 +- test/test_inference/test_imports.py | 6 +-- test/test_inference/test_literals.py | 2 +- test/test_inference/test_precedence.py | 2 +- test/test_inference/test_signature.py | 2 +- test/test_inference/test_sys_path.py | 2 +- test/test_settings.py | 6 +-- 81 files changed, 430 insertions(+), 430 deletions(-) delete mode 100644 jedi/evaluate/context/__init__.py rename jedi/{evaluate => inference}/__init__.py (94%) rename jedi/{evaluate => inference}/analysis.py (97%) rename jedi/{evaluate => inference}/arguments.py (94%) rename jedi/{evaluate => inference}/base_context.py (95%) rename jedi/{evaluate => inference}/cache.py (100%) rename jedi/{evaluate => inference}/compiled/__init__.py (93%) rename jedi/{evaluate => inference}/compiled/access.py (99%) rename jedi/{evaluate => inference}/compiled/context.py (95%) rename jedi/{evaluate => inference}/compiled/getattr_static.py (100%) rename jedi/{evaluate => inference}/compiled/mixed.py (95%) rename jedi/{evaluate => inference}/compiled/subprocess/__init__.py (98%) rename jedi/{evaluate => inference}/compiled/subprocess/__main__.py (93%) rename jedi/{evaluate => inference}/compiled/subprocess/functions.py (98%) create mode 100644 jedi/inference/context/__init__.py rename jedi/{evaluate => inference}/context/decorator.py (87%) rename jedi/{evaluate => inference}/context/function.py (93%) rename jedi/{evaluate => inference}/context/instance.py (95%) rename jedi/{evaluate => inference}/context/iterable.py (97%) rename jedi/{evaluate => inference}/context/klass.py (93%) rename jedi/{evaluate => inference}/context/module.py (94%) rename jedi/{evaluate => inference}/context/namespace.py (85%) rename jedi/{evaluate => inference}/docstrings.py (94%) rename jedi/{evaluate => inference}/dynamic.py (93%) rename jedi/{evaluate => inference}/filters.py (97%) rename jedi/{evaluate => inference}/finder.py (96%) rename jedi/{evaluate => inference}/flow_analysis.py (98%) rename jedi/{evaluate => inference}/gradual/__init__.py (100%) rename jedi/{evaluate => inference}/gradual/annotation.py (96%) rename jedi/{evaluate => inference}/gradual/conversion.py (95%) rename jedi/{evaluate => inference}/gradual/stub_context.py (93%) rename jedi/{evaluate => inference}/gradual/typeshed.py (98%) rename jedi/{evaluate => inference}/gradual/typing.py (96%) rename jedi/{evaluate => inference}/gradual/utils.py (92%) rename jedi/{evaluate => inference}/helpers.py (97%) rename jedi/{evaluate => inference}/imports.py (95%) rename jedi/{evaluate => inference}/lazy_context.py (96%) rename jedi/{evaluate => inference}/names.py (98%) rename jedi/{evaluate => inference}/param.py (97%) rename jedi/{evaluate => inference}/parser_cache.py (66%) rename jedi/{evaluate => inference}/recursion.py (97%) rename jedi/{evaluate => inference}/signature.py (98%) rename jedi/{evaluate => inference}/star_args.py (96%) rename jedi/{evaluate => inference}/syntax_tree.py (96%) rename jedi/{evaluate => inference}/sys_path.py (97%) rename jedi/{evaluate => inference}/usages.py (96%) rename jedi/{evaluate => inference}/utils.py (100%) diff --git a/.coveragerc b/.coveragerc index 005e74fb..b063441c 100644 --- a/.coveragerc +++ b/.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 diff --git a/conftest.py b/conftest.py index 765c865c..35aa6073 100644 --- a/conftest.py +++ b/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', ] diff --git a/docs/docs/development.rst b/docs/docs/development.rst index 71ac5b1f..37c69568 100644 --- a/docs/docs/development.rst +++ b/docs/docs/development.rst @@ -47,12 +47,12 @@ The Jedi Core The core of Jedi consists of three parts: - :ref:`Parser ` -- :ref:`Python type inference ` +- :ref:`Python type inference ` - :ref:`API ` -Most people are probably interested in :ref:`type inference `, +Most people are probably interested in :ref:`type inference `, because that's where all the magic happens. I need to introduce the :ref:`parser -` first, because :mod:`jedi.evaluate` uses it extensively. +` 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 `_. -.. _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.evaluate.context.klass.ClassContext - jedi.evaluate.context.function.FunctionContext - jedi.evaluate.context.function.FunctionExecutionContext + jedi.inference.context.instance.TreeInstance + jedi.inference.context.klass.ClassContext + jedi.inference.context.function.FunctionContext + 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: diff --git a/jedi/api/__init__.py b/jedi/api/__init__.py index 8b00258e..cdd9def5 100644 --- a/jedi/api/__init__.py +++ b/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.evaluate import imports -from jedi.evaluate import usages -from jedi.evaluate.arguments import try_iter_content -from jedi.evaluate.helpers import get_module_names, evaluate_call_of_leaf -from jedi.evaluate.sys_path import transform_path_to_dotted -from jedi.evaluate.names import TreeNameDefinition, ParamName -from jedi.evaluate.syntax_tree import tree_name_to_contexts -from jedi.evaluate.context import ModuleContext -from jedi.evaluate.base_context import ContextSet -from jedi.evaluate.context.iterable import unpack_tuple_to_dict -from jedi.evaluate.gradual.conversion import convert_names, convert_contexts -from jedi.evaluate.gradual.utils import load_proper_stub_module +from jedi.inference import Evaluator +from jedi.inference import imports +from jedi.inference import usages +from jedi.inference.arguments import try_iter_content +from jedi.inference.helpers import get_module_names, infer_call_of_leaf +from jedi.inference.sys_path import transform_path_to_dotted +from jedi.inference.names import TreeNameDefinition, ParamName +from jedi.inference.syntax_tree import tree_name_to_contexts +from jedi.inference.context import ModuleContext +from jedi.inference.base_context import ContextSet +from jedi.inference.context.iterable import unpack_tuple_to_dict +from jedi.inference.gradual.conversion import convert_names, convert_contexts +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() diff --git a/jedi/api/classes.py b/jedi/api/classes.py index 101414c3..ccf99e15 100644 --- a/jedi/api/classes.py +++ b/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.evaluate import compiled -from jedi.evaluate.imports import ImportName -from jedi.evaluate.context import FunctionExecutionContext -from jedi.evaluate.gradual.typeshed import StubModuleContext -from jedi.evaluate.gradual.conversion import convert_names, convert_contexts -from jedi.evaluate.base_context import ContextSet +from jedi.inference import imports +from jedi.inference import compiled +from jedi.inference.imports import ImportName +from jedi.inference.context import FunctionExecutionContext +from jedi.inference.gradual.typeshed import StubModuleContext +from jedi.inference.gradual.conversion import convert_names, convert_contexts +from jedi.inference.base_context import ContextSet from jedi.api.keywords import KeywordName diff --git a/jedi/api/completion.py b/jedi/api/completion.py index 9e87c7a4..6b0b6b0d 100644 --- a/jedi/api/completion.py +++ b/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.evaluate.helpers import evaluate_call_of_leaf, parse_dotted_names -from jedi.evaluate.filters import get_global_filters -from jedi.evaluate.gradual.conversion import convert_contexts +from jedi.inference import imports +from jedi.inference.helpers import infer_call_of_leaf, parse_dotted_names +from jedi.inference.filters import get_global_filters +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: diff --git a/jedi/api/environment.py b/jedi/api/environment.py index 33b9f28a..03ba4544 100644 --- a/jedi/api/environment.py +++ b/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 diff --git a/jedi/api/file_name.py b/jedi/api/file_name.py index 2a2c4e60..e9841ace 100644 --- a/jedi/api/file_name.py +++ b/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 diff --git a/jedi/api/helpers.py b/jedi/api/helpers.py index 6fafb116..192fccc6 100644 --- a/jedi/api/helpers.py +++ b/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.evaluate.syntax_tree import eval_atom -from jedi.evaluate.helpers import evaluate_call_of_leaf -from jedi.evaluate.compiled import get_string_context_set +from jedi.inference.base_context import NO_CONTEXTS +from jedi.inference.syntax_tree import eval_atom +from jedi.inference.helpers import infer_call_of_leaf +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(), diff --git a/jedi/api/interpreter.py b/jedi/api/interpreter.py index 515e0078..4aaa59b4 100644 --- a/jedi/api/interpreter.py +++ b/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.evaluate import compiled -from jedi.evaluate.compiled import mixed -from jedi.evaluate.compiled.access import create_access_path -from jedi.evaluate.base_context import ContextWrapper +from jedi.inference.context import ModuleContext +from jedi.inference import compiled +from jedi.inference.compiled import mixed +from jedi.inference.compiled.access import create_access_path +from jedi.inference.base_context import ContextWrapper def _create(evaluator, obj): diff --git a/jedi/api/keywords.py b/jedi/api/keywords.py index cc301b8d..fa1933ad 100644 --- a/jedi/api/keywords.py +++ b/jedi/api/keywords.py @@ -1,7 +1,7 @@ import pydoc -from jedi.evaluate.utils import ignored -from jedi.evaluate.names import AbstractArbitraryName +from jedi.inference.utils import ignored +from jedi.inference.names import AbstractArbitraryName try: from pydoc_data import topics as pydoc_topics diff --git a/jedi/api/project.py b/jedi/api/project.py index 63ee2b8d..02d5fba3 100644 --- a/jedi/api/project.py +++ b/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.evaluate.cache import evaluator_as_method_param_cache +from jedi.inference.sys_path import discover_buildout_paths +from jedi.inference.cache import evaluator_as_method_param_cache from jedi.common.utils import traverse_parents _CONFIG_FOLDER = '.jedi' diff --git a/jedi/evaluate/context/__init__.py b/jedi/evaluate/context/__init__.py deleted file mode 100644 index 56f6495b..00000000 --- a/jedi/evaluate/context/__init__.py +++ /dev/null @@ -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 diff --git a/jedi/evaluate/__init__.py b/jedi/inference/__init__.py similarity index 94% rename from jedi/evaluate/__init__.py rename to jedi/inference/__init__.py index b6cc55c6..e0d22f27 100644 --- a/jedi/evaluate/__init__.py +++ b/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.evaluate import imports -from jedi.evaluate import recursion -from jedi.evaluate.cache import evaluator_function_cache -from jedi.evaluate import helpers -from jedi.evaluate.names import TreeNameDefinition, ParamName -from jedi.evaluate.base_context import ContextualizedName, ContextualizedNode, \ +from jedi.inference.utils import unite +from jedi.inference import imports +from jedi.inference import recursion +from jedi.inference.cache import evaluator_function_cache +from jedi.inference import helpers +from jedi.inference.names import TreeNameDefinition, ParamName +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.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, \ +from jedi.inference.context.iterable import CompForContext +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] - if to_evaluate[0] == 'await': - to_evaluate.pop(0) - context_set = context.eval_node(to_evaluate[0]) - for trailer in to_evaluate[1:]: + to_infer = trailer.parent.children[:i] + if to_infer[0] == 'await': + to_infer.pop(0) + context_set = context.eval_node(to_infer[0]) + 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( diff --git a/jedi/evaluate/analysis.py b/jedi/inference/analysis.py similarity index 97% rename from jedi/evaluate/analysis.py rename to jedi/inference/analysis.py index 47f1bbd5..4d90b938 100644 --- a/jedi/evaluate/analysis.py +++ b/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 diff --git a/jedi/evaluate/arguments.py b/jedi/inference/arguments.py similarity index 94% rename from jedi/evaluate/arguments.py rename to jedi/inference/arguments.py index bd271a8f..2f927bdc 100644 --- a/jedi/evaluate/arguments.py +++ b/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.evaluate import analysis -from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \ +from jedi.inference.utils import PushBackIterator +from jedi.inference import analysis +from jedi.inference.lazy_context import LazyKnownContext, LazyKnownContexts, \ LazyTreeContext, get_merged_lazy_context -from jedi.evaluate.names import ParamName, TreeNameDefinition -from jedi.evaluate.base_context import NO_CONTEXTS, ContextSet, ContextualizedNode -from jedi.evaluate.context import iterable -from jedi.evaluate.cache import evaluator_as_method_param_cache -from jedi.evaluate.param import get_executed_params_and_issues, ExecutedParam +from jedi.inference.names import ParamName, TreeNameDefinition +from jedi.inference.base_context import NO_CONTEXTS, ContextSet, ContextualizedNode +from jedi.inference.context import iterable +from jedi.inference.cache import evaluator_as_method_param_cache +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. diff --git a/jedi/evaluate/base_context.py b/jedi/inference/base_context.py similarity index 95% rename from jedi/evaluate/base_context.py rename to jedi/inference/base_context.py index 9214fb4e..158b6ea1 100644 --- a/jedi/evaluate/base_context.py +++ b/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.evaluate.utils import safe_property -from jedi.evaluate.cache import evaluator_as_method_param_cache +from jedi.inference.helpers import SimpleGetItemNotFound +from jedi.inference.utils import safe_property +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( diff --git a/jedi/evaluate/cache.py b/jedi/inference/cache.py similarity index 100% rename from jedi/evaluate/cache.py rename to jedi/inference/cache.py diff --git a/jedi/evaluate/compiled/__init__.py b/jedi/inference/compiled/__init__.py similarity index 93% rename from jedi/evaluate/compiled/__init__.py rename to jedi/inference/compiled/__init__.py index 2fb81192..a5e80dcc 100644 --- a/jedi/evaluate/compiled/__init__.py +++ b/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): diff --git a/jedi/evaluate/compiled/access.py b/jedi/inference/compiled/access.py similarity index 99% rename from jedi/evaluate/compiled/access.py rename to jedi/inference/compiled/access.py index 18aacf57..1582c2a0 100644 --- a/jedi/evaluate/compiled/access.py +++ b/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) diff --git a/jedi/evaluate/compiled/context.py b/jedi/inference/compiled/context.py similarity index 95% rename from jedi/evaluate/compiled/context.py rename to jedi/inference/compiled/context.py index f7c91b59..6a893cce 100644 --- a/jedi/evaluate/compiled/context.py +++ b/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.evaluate.names import AbstractNameDefinition, ContextNameMixin, \ +from jedi.inference.filters import AbstractFilter +from jedi.inference.names import AbstractNameDefinition, ContextNameMixin, \ ParamNameInterface -from jedi.evaluate.base_context import Context, ContextSet, NO_CONTEXTS -from jedi.evaluate.lazy_context import LazyKnownContext -from jedi.evaluate.compiled.access import _sentinel -from jedi.evaluate.cache import evaluator_function_cache -from jedi.evaluate.helpers import reraise_getitem_errors -from jedi.evaluate.signature import BuiltinSignature +from jedi.inference.base_context import Context, ContextSet, NO_CONTEXTS +from jedi.inference.lazy_context import LazyKnownContext +from jedi.inference.compiled.access import _sentinel +from jedi.inference.cache import evaluator_function_cache +from jedi.inference.helpers import reraise_getitem_errors +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.evaluate.compiled import builtin_from_name + from jedi.inference import docstrings + 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: diff --git a/jedi/evaluate/compiled/getattr_static.py b/jedi/inference/compiled/getattr_static.py similarity index 100% rename from jedi/evaluate/compiled/getattr_static.py rename to jedi/inference/compiled/getattr_static.py diff --git a/jedi/evaluate/compiled/mixed.py b/jedi/inference/compiled/mixed.py similarity index 95% rename from jedi/evaluate/compiled/mixed.py rename to jedi/inference/compiled/mixed.py index a11aefb7..1b7d1d61 100644 --- a/jedi/evaluate/compiled/mixed.py +++ b/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.evaluate.helpers import SimpleGetItemNotFound -from jedi.evaluate.context import ModuleContext -from jedi.evaluate.cache import evaluator_function_cache -from jedi.evaluate.compiled.getattr_static import getattr_static -from jedi.evaluate.compiled.access import compiled_objects_cache, \ +from jedi.inference.base_context import ContextSet, ContextWrapper +from jedi.inference.helpers import SimpleGetItemNotFound +from jedi.inference.context import ModuleContext +from jedi.inference.cache import evaluator_function_cache +from jedi.inference.compiled.getattr_static import getattr_static +from jedi.inference.compiled.access import compiled_objects_cache, \ ALLOWED_GETITEM_TYPES, get_api_type -from jedi.evaluate.compiled.context import create_cached_compiled_object -from jedi.evaluate.gradual.conversion import to_stub +from jedi.inference.compiled.context import create_cached_compiled_object +from jedi.inference.gradual.conversion import to_stub _sentinel = object() diff --git a/jedi/evaluate/compiled/subprocess/__init__.py b/jedi/inference/compiled/subprocess/__init__.py similarity index 98% rename from jedi/evaluate/compiled/subprocess/__init__.py rename to jedi/inference/compiled/subprocess/__init__.py index dea2f66d..bb32bab7 100644 --- a/jedi/evaluate/compiled/subprocess/__init__.py +++ b/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.evaluate.compiled.access import DirectObjectAccess, AccessPath, \ +from jedi.inference.compiled.subprocess import functions +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] diff --git a/jedi/evaluate/compiled/subprocess/__main__.py b/jedi/inference/compiled/subprocess/__main__.py similarity index 93% rename from jedi/evaluate/compiled/subprocess/__main__.py rename to jedi/inference/compiled/subprocess/__main__.py index 4be28204..5e92229f 100644 --- a/jedi/evaluate/compiled/subprocess/__main__.py +++ b/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 diff --git a/jedi/evaluate/compiled/subprocess/functions.py b/jedi/inference/compiled/subprocess/functions.py similarity index 98% rename from jedi/evaluate/compiled/subprocess/functions.py rename to jedi/inference/compiled/subprocess/functions.py index b3fdac04..b312346c 100644 --- a/jedi/evaluate/compiled/subprocess/functions.py +++ b/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 diff --git a/jedi/inference/context/__init__.py b/jedi/inference/context/__init__.py new file mode 100644 index 00000000..e3297f50 --- /dev/null +++ b/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 diff --git a/jedi/evaluate/context/decorator.py b/jedi/inference/context/decorator.py similarity index 87% rename from jedi/evaluate/context/decorator.py rename to jedi/inference/context/decorator.py index 317c5f43..07650326 100644 --- a/jedi/evaluate/context/decorator.py +++ b/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): diff --git a/jedi/evaluate/context/function.py b/jedi/inference/context/function.py similarity index 93% rename from jedi/evaluate/context/function.py rename to jedi/inference/context/function.py index 0128db9e..03a37449 100644 --- a/jedi/evaluate/context/function.py +++ b/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.evaluate import compiled -from jedi.evaluate import recursion -from jedi.evaluate import docstrings -from jedi.evaluate import flow_analysis -from jedi.evaluate import helpers -from jedi.evaluate.signature import TreeSignature -from jedi.evaluate.arguments import AnonymousArguments -from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter -from jedi.evaluate.names import ContextName, AbstractNameDefinition, ParamName -from jedi.evaluate.base_context import ContextualizedNode, NO_CONTEXTS, \ +from jedi.inference.cache import evaluator_method_cache, CachedMetaClass +from jedi.inference import compiled +from jedi.inference import recursion +from jedi.inference import docstrings +from jedi.inference import flow_analysis +from jedi.inference import helpers +from jedi.inference.signature import TreeSignature +from jedi.inference.arguments import AnonymousArguments +from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter +from jedi.inference.names import ContextName, AbstractNameDefinition, ParamName +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.evaluate.helpers import contexts_from_qualified_names +from jedi.inference.parser_cache import get_yield_exprs +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: diff --git a/jedi/evaluate/context/instance.py b/jedi/inference/context/instance.py similarity index 95% rename from jedi/evaluate/context/instance.py rename to jedi/inference/context/instance.py index f16d0fda..382d3233 100644 --- a/jedi/evaluate/context/instance.py +++ b/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.evaluate.compiled.context import CompiledObjectFilter -from jedi.evaluate.helpers import contexts_from_qualified_names -from jedi.evaluate.filters import AbstractFilter -from jedi.evaluate.names import ContextName, TreeNameDefinition -from jedi.evaluate.base_context import Context, NO_CONTEXTS, ContextSet, \ +from jedi.inference import compiled +from jedi.inference.compiled.context import CompiledObjectFilter +from jedi.inference.helpers import contexts_from_qualified_names +from jedi.inference.filters import AbstractFilter +from jedi.inference.names import ContextName, TreeNameDefinition +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.evaluate.cache import evaluator_method_cache -from jedi.evaluate.arguments import AnonymousArguments, \ +from jedi.inference.lazy_context import LazyKnownContext, LazyKnownContexts +from jedi.inference.cache import evaluator_method_cache +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(): diff --git a/jedi/evaluate/context/iterable.py b/jedi/inference/context/iterable.py similarity index 97% rename from jedi/evaluate/context/iterable.py rename to jedi/inference/context/iterable.py index befcc8e8..3c951148 100644 --- a/jedi/evaluate/context/iterable.py +++ b/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.evaluate import analysis -from jedi.evaluate import recursion -from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \ +from jedi.inference import compiled +from jedi.inference import analysis +from jedi.inference import recursion +from jedi.inference.lazy_context import LazyKnownContext, LazyKnownContexts, \ LazyTreeContext -from jedi.evaluate.helpers import get_int_or_none, is_string, \ - predefine_names, evaluate_call_of_leaf, reraise_getitem_errors, \ +from jedi.inference.helpers import get_int_or_none, is_string, \ + predefine_names, infer_call_of_leaf, reraise_getitem_errors, \ SimpleGetItemNotFound -from jedi.evaluate.utils import safe_property, to_list -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.filters import ParserTreeFilter, LazyAttributeOverwrite, \ +from jedi.inference.utils import safe_property, to_list +from jedi.inference.cache import evaluator_method_cache +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: diff --git a/jedi/evaluate/context/klass.py b/jedi/inference/context/klass.py similarity index 93% rename from jedi/evaluate/context/klass.py rename to jedi/inference/context/klass.py index d8e0ca6e..3b283ece 100644 --- a/jedi/evaluate/context/klass.py +++ b/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.evaluate.lazy_context import LazyKnownContexts -from jedi.evaluate.filters import ParserTreeFilter -from jedi.evaluate.names import TreeNameDefinition, ContextName -from jedi.evaluate.arguments import unpack_arglist, ValuesArguments -from jedi.evaluate.base_context import ContextSet, iterator_to_context_set, \ +from jedi.inference import compiled +from jedi.inference.lazy_context import LazyKnownContexts +from jedi.inference.filters import ParserTreeFilter +from jedi.inference.names import TreeNameDefinition, ContextName +from jedi.inference.arguments import unpack_arglist, ValuesArguments +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(): """ diff --git a/jedi/evaluate/context/module.py b/jedi/inference/context/module.py similarity index 94% rename from jedi/evaluate/context/module.py rename to jedi/inference/context/module.py index 28f92f3b..08c400a3 100644 --- a/jedi/evaluate/context/module.py +++ b/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.evaluate.names import ContextNameMixin, AbstractNameDefinition -from jedi.evaluate.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter -from jedi.evaluate import compiled -from jedi.evaluate.base_context import TreeContext -from jedi.evaluate.names import SubModuleName -from jedi.evaluate.helpers import contexts_from_qualified_names -from jedi.evaluate.compiled import create_simple_object -from jedi.evaluate.base_context import ContextSet +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.names import ContextNameMixin, AbstractNameDefinition +from jedi.inference.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter +from jedi.inference import compiled +from jedi.inference.base_context import TreeContext +from jedi.inference.names import SubModuleName +from jedi.inference.helpers import contexts_from_qualified_names +from jedi.inference.compiled import create_simple_object +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(): diff --git a/jedi/evaluate/context/namespace.py b/jedi/inference/context/namespace.py similarity index 85% rename from jedi/evaluate/context/namespace.py rename to jedi/inference/context/namespace.py index 12c8b3a6..a6e1e225 100644 --- a/jedi/evaluate/context/namespace.py +++ b/jedi/inference/context/namespace.py @@ -1,8 +1,8 @@ -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.filters import DictFilter -from jedi.evaluate.names import ContextNameMixin, AbstractNameDefinition -from jedi.evaluate.base_context import Context -from jedi.evaluate.context.module import SubModuleDictMixin +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.filters import DictFilter +from jedi.inference.names import ContextNameMixin, AbstractNameDefinition +from jedi.inference.base_context import Context +from jedi.inference.context.module import SubModuleDictMixin class ImplicitNSName(ContextNameMixin, AbstractNameDefinition): diff --git a/jedi/evaluate/docstrings.py b/jedi/inference/docstrings.py similarity index 94% rename from jedi/evaluate/docstrings.py rename to jedi/inference/docstrings.py index d38dbf19..f5a6b7b3 100644 --- a/jedi/evaluate/docstrings.py +++ b/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.evaluate.cache import evaluator_method_cache -from jedi.evaluate.base_context import iterator_to_context_set, ContextSet, \ +from jedi.inference.utils import indent_block +from jedi.inference.cache import evaluator_method_cache +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.evaluate.context import FunctionExecutionContext + from jedi.inference.context.instance import InstanceArguments + from jedi.inference.context import FunctionExecutionContext def eval_docstring(docstring): return ContextSet( diff --git a/jedi/evaluate/dynamic.py b/jedi/inference/dynamic.py similarity index 93% rename from jedi/evaluate/dynamic.py rename to jedi/inference/dynamic.py index 7acc66cb..85a4ce82 100644 --- a/jedi/evaluate/dynamic.py +++ b/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.evaluate import imports -from jedi.evaluate.arguments import TreeArguments -from jedi.evaluate.param import create_default_params -from jedi.evaluate.helpers import is_stdlib_path -from jedi.evaluate.utils import to_list +from jedi.inference.cache import evaluator_function_cache +from jedi.inference import imports +from jedi.inference.arguments import TreeArguments +from jedi.inference.param import create_default_params +from jedi.inference.helpers import is_stdlib_path +from jedi.inference.utils import to_list from jedi.parser_utils import get_parent_scope -from jedi.evaluate.context import ModuleContext, instance -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS -from jedi.evaluate import recursion +from jedi.inference.context import ModuleContext, instance +from jedi.inference.base_context import ContextSet, NO_CONTEXTS +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] diff --git a/jedi/evaluate/filters.py b/jedi/inference/filters.py similarity index 97% rename from jedi/evaluate/filters.py rename to jedi/inference/filters.py index 0b758ea7..b9bf264e 100644 --- a/jedi/evaluate/filters.py +++ b/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.evaluate.base_context import ContextSet, Context, ContextWrapper, \ +from jedi.inference import flow_analysis +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.evaluate.names import TreeNameDefinition, ParamName, AbstractNameDefinition +from jedi.inference.utils import to_list +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( diff --git a/jedi/evaluate/finder.py b/jedi/inference/finder.py similarity index 96% rename from jedi/evaluate/finder.py rename to jedi/inference/finder.py index 9a521a51..3e57cb20 100644 --- a/jedi/evaluate/finder.py +++ b/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.evaluate import analysis -from jedi.evaluate import flow_analysis -from jedi.evaluate.arguments import TreeArguments -from jedi.evaluate import helpers -from jedi.evaluate.context import iterable -from jedi.evaluate.filters import get_global_filters -from jedi.evaluate.names import TreeNameDefinition -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS +from jedi.inference import compiled +from jedi.inference import analysis +from jedi.inference import flow_analysis +from jedi.inference.arguments import TreeArguments +from jedi.inference import helpers +from jedi.inference.context import iterable +from jedi.inference.filters import get_global_filters +from jedi.inference.names import TreeNameDefinition +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): diff --git a/jedi/evaluate/flow_analysis.py b/jedi/inference/flow_analysis.py similarity index 98% rename from jedi/evaluate/flow_analysis.py rename to jedi/inference/flow_analysis.py index 474071f1..a805ecc9 100644 --- a/jedi/evaluate/flow_analysis.py +++ b/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): diff --git a/jedi/evaluate/gradual/__init__.py b/jedi/inference/gradual/__init__.py similarity index 100% rename from jedi/evaluate/gradual/__init__.py rename to jedi/inference/gradual/__init__.py diff --git a/jedi/evaluate/gradual/annotation.py b/jedi/inference/gradual/annotation.py similarity index 96% rename from jedi/evaluate/gradual/annotation.py rename to jedi/inference/gradual/annotation.py index c0145129..077202dc 100644 --- a/jedi/evaluate/gradual/annotation.py +++ b/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.evaluate.base_context import ContextSet, NO_CONTEXTS -from jedi.evaluate.gradual.typing import TypeVar, LazyGenericClass, \ +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.base_context import ContextSet, NO_CONTEXTS +from jedi.inference.gradual.typing import TypeVar, LazyGenericClass, \ AbstractAnnotatedClass -from jedi.evaluate.gradual.typing import GenericClass -from jedi.evaluate.helpers import is_string -from jedi.evaluate.compiled import builtin_from_name +from jedi.inference.gradual.typing import GenericClass +from jedi.inference.helpers import is_string +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 diff --git a/jedi/evaluate/gradual/conversion.py b/jedi/inference/gradual/conversion.py similarity index 95% rename from jedi/evaluate/gradual/conversion.py rename to jedi/inference/gradual/conversion.py index 32067612..a3ad6757 100644 --- a/jedi/evaluate/gradual/conversion.py +++ b/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.evaluate.gradual.stub_context import StubModuleContext +from jedi.inference.utils import to_list +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, diff --git a/jedi/evaluate/gradual/stub_context.py b/jedi/inference/gradual/stub_context.py similarity index 93% rename from jedi/evaluate/gradual/stub_context.py rename to jedi/inference/gradual/stub_context.py index 94090c11..cdf5a92f 100644 --- a/jedi/evaluate/gradual/stub_context.py +++ b/jedi/inference/gradual/stub_context.py @@ -1,8 +1,8 @@ -from jedi.evaluate.base_context import ContextWrapper -from jedi.evaluate.context.module import ModuleContext -from jedi.evaluate.filters import ParserTreeFilter, \ +from jedi.inference.base_context import ContextWrapper +from jedi.inference.context.module import ModuleContext +from jedi.inference.filters import ParserTreeFilter, \ TreeNameDefinition -from jedi.evaluate.gradual.typing import TypingModuleFilterWrapper +from jedi.inference.gradual.typing import TypingModuleFilterWrapper class StubModuleContext(ModuleContext): diff --git a/jedi/evaluate/gradual/typeshed.py b/jedi/inference/gradual/typeshed.py similarity index 98% rename from jedi/evaluate/gradual/typeshed.py rename to jedi/inference/gradual/typeshed.py index 5a386c05..a339a810 100644 --- a/jedi/evaluate/gradual/typeshed.py +++ b/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.evaluate.gradual.stub_context import TypingModuleWrapper, StubModuleContext +from jedi.inference.base_context import ContextSet, NO_CONTEXTS +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') diff --git a/jedi/evaluate/gradual/typing.py b/jedi/inference/gradual/typing.py similarity index 96% rename from jedi/evaluate/gradual/typing.py rename to jedi/inference/gradual/typing.py index 20f23212..74b24bcf 100644 --- a/jedi/evaluate/gradual/typing.py +++ b/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.evaluate.compiled import builtin_from_name -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, Context, \ +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.compiled import builtin_from_name +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.evaluate.context.iterable import SequenceLiteralContext -from jedi.evaluate.arguments import repack_with_argument_clinic -from jedi.evaluate.utils import to_list -from jedi.evaluate.filters import FilterWrapper -from jedi.evaluate.names import NameWrapper, AbstractTreeName, \ +from jedi.inference.lazy_context import LazyKnownContexts +from jedi.inference.context.iterable import SequenceLiteralContext +from jedi.inference.arguments import repack_with_argument_clinic +from jedi.inference.utils import to_list +from jedi.inference.filters import FilterWrapper +from jedi.inference.names import NameWrapper, AbstractTreeName, \ AbstractNameDefinition, ContextName -from jedi.evaluate.helpers import is_string -from jedi.evaluate.context.klass import ClassMixin, ClassFilter +from jedi.inference.helpers import is_string +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() diff --git a/jedi/evaluate/gradual/utils.py b/jedi/inference/gradual/utils.py similarity index 92% rename from jedi/evaluate/gradual/utils.py rename to jedi/inference/gradual/utils.py index 6bc60e69..18ba41cd 100644 --- a/jedi/evaluate/gradual/utils.py +++ b/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): diff --git a/jedi/evaluate/helpers.py b/jedi/inference/helpers.py similarity index 97% rename from jedi/evaluate/helpers.py rename to jedi/inference/helpers.py index 78d2a7fd..87c8987f 100644 --- a/jedi/evaluate/helpers.py +++ b/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 diff --git a/jedi/evaluate/imports.py b/jedi/inference/imports.py similarity index 95% rename from jedi/evaluate/imports.py rename to jedi/inference/imports.py index f7ec8c31..0e3d26bb 100644 --- a/jedi/evaluate/imports.py +++ b/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.evaluate import helpers -from jedi.evaluate import compiled -from jedi.evaluate import analysis -from jedi.evaluate.utils import unite -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.names import ImportName, SubModuleName -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS -from jedi.evaluate.gradual.typeshed import import_module_decorator -from jedi.evaluate.context.module import iter_module_names +from jedi.inference import sys_path +from jedi.inference import helpers +from jedi.inference import compiled +from jedi.inference import analysis +from jedi.inference.utils import unite +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.names import ImportName, SubModuleName +from jedi.inference.base_context import ContextSet, NO_CONTEXTS +from jedi.inference.gradual.typeshed import import_module_decorator +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, diff --git a/jedi/evaluate/lazy_context.py b/jedi/inference/lazy_context.py similarity index 96% rename from jedi/evaluate/lazy_context.py rename to jedi/inference/lazy_context.py index 0501d3b8..1d3ef853 100644 --- a/jedi/evaluate/lazy_context.py +++ b/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 diff --git a/jedi/evaluate/names.py b/jedi/inference/names.py similarity index 98% rename from jedi/evaluate/names.py rename to jedi/inference/names.py index b1c2d403..0d200a70 100644 --- a/jedi/evaluate/names.py +++ b/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() diff --git a/jedi/evaluate/param.py b/jedi/inference/param.py similarity index 97% rename from jedi/evaluate/param.py rename to jedi/inference/param.py index ffec77e3..a0809e0d 100644 --- a/jedi/evaluate/param.py +++ b/jedi/inference/param.py @@ -1,12 +1,12 @@ from collections import defaultdict from jedi import debug -from jedi.evaluate.utils import PushBackIterator -from jedi.evaluate import analysis -from jedi.evaluate.lazy_context import LazyKnownContext, \ +from jedi.inference.utils import PushBackIterator +from jedi.inference import analysis +from jedi.inference.lazy_context import LazyKnownContext, \ LazyTreeContext, LazyUnknownContext -from jedi.evaluate import docstrings -from jedi.evaluate.context import iterable +from jedi.inference import docstrings +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): diff --git a/jedi/evaluate/parser_cache.py b/jedi/inference/parser_cache.py similarity index 66% rename from jedi/evaluate/parser_cache.py rename to jedi/inference/parser_cache.py index 84fe52d9..5905aa1a 100644 --- a/jedi/evaluate/parser_cache.py +++ b/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() diff --git a/jedi/evaluate/recursion.py b/jedi/inference/recursion.py similarity index 97% rename from jedi/evaluate/recursion.py rename to jedi/inference/recursion.py index f86dedab..ab5a1b8c 100644 --- a/jedi/evaluate/recursion.py +++ b/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 `. -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 diff --git a/jedi/evaluate/signature.py b/jedi/inference/signature.py similarity index 98% rename from jedi/evaluate/signature.py rename to jedi/inference/signature.py index 43d3d5d1..e189d4bc 100644 --- a/jedi/evaluate/signature.py +++ b/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 diff --git a/jedi/evaluate/star_args.py b/jedi/inference/star_args.py similarity index 96% rename from jedi/evaluate/star_args.py rename to jedi/inference/star_args.py index 0a7768a0..fa27d87b 100644 --- a/jedi/evaluate/star_args.py +++ b/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.evaluate.names import ParamNameWrapper +from jedi.inference.utils import to_list +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' diff --git a/jedi/evaluate/syntax_tree.py b/jedi/inference/syntax_tree.py similarity index 96% rename from jedi/evaluate/syntax_tree.py rename to jedi/inference/syntax_tree.py index c5019c0f..af8cf2a9 100644 --- a/jedi/evaluate/syntax_tree.py +++ b/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.evaluate import compiled -from jedi.evaluate import recursion -from jedi.evaluate import helpers -from jedi.evaluate import analysis -from jedi.evaluate import imports -from jedi.evaluate import arguments -from jedi.evaluate.context import ClassContext, FunctionContext -from jedi.evaluate.context import iterable -from jedi.evaluate.context import TreeInstance -from jedi.evaluate.finder import NameFinder -from jedi.evaluate.helpers import is_string, is_literal, is_number -from jedi.evaluate.compiled.access import COMPARISON_OPERATORS -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.gradual.stub_context import VersionInfo -from jedi.evaluate.gradual import annotation -from jedi.evaluate.context.decorator import Decoratee +from jedi.inference.lazy_context import LazyTreeContext +from jedi.inference import compiled +from jedi.inference import recursion +from jedi.inference import helpers +from jedi.inference import analysis +from jedi.inference import imports +from jedi.inference import arguments +from jedi.inference.context import ClassContext, FunctionContext +from jedi.inference.context import iterable +from jedi.inference.context import TreeInstance +from jedi.inference.finder import NameFinder +from jedi.inference.helpers import is_string, is_literal, is_number +from jedi.inference.compiled.access import COMPARISON_OPERATORS +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.gradual.stub_context import VersionInfo +from jedi.inference.gradual import annotation +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) diff --git a/jedi/evaluate/sys_path.py b/jedi/inference/sys_path.py similarity index 97% rename from jedi/evaluate/sys_path.py rename to jedi/inference/sys_path.py index 8dea434b..a07b08c8 100644 --- a/jedi/evaluate/sys_path.py +++ b/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.evaluate.base_context import ContextualizedNode -from jedi.evaluate.helpers import is_string +from jedi.inference.cache import evaluator_method_cache +from jedi.inference.base_context import ContextualizedNode +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, diff --git a/jedi/evaluate/usages.py b/jedi/inference/usages.py similarity index 96% rename from jedi/evaluate/usages.py rename to jedi/inference/usages.py index 9c8d2651..d7f8e2fe 100644 --- a/jedi/evaluate/usages.py +++ b/jedi/inference/usages.py @@ -1,5 +1,5 @@ -from jedi.evaluate import imports -from jedi.evaluate.names import TreeNameDefinition +from jedi.inference import imports +from jedi.inference.names import TreeNameDefinition def _resolve_names(definition_names, avoid_names=()): diff --git a/jedi/evaluate/utils.py b/jedi/inference/utils.py similarity index 100% rename from jedi/evaluate/utils.py rename to jedi/inference/utils.py diff --git a/jedi/plugins/stdlib.py b/jedi/plugins/stdlib.py index 0f98f1d5..a9f6a44a 100644 --- a/jedi/plugins/stdlib.py +++ b/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.evaluate.helpers import get_str_or_none -from jedi.evaluate.arguments import ValuesArguments, \ +from jedi.inference.utils import safe_property +from jedi.inference.helpers import get_str_or_none +from jedi.inference.arguments import ValuesArguments, \ repack_with_argument_clinic, AbstractArguments, TreeArgumentsWrapper -from jedi.evaluate import analysis -from jedi.evaluate import compiled -from jedi.evaluate.context.instance import BoundMethod, InstanceArguments -from jedi.evaluate.base_context import ContextualizedNode, \ +from jedi.inference import analysis +from jedi.inference import compiled +from jedi.inference.context.instance import BoundMethod, InstanceArguments +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.evaluate.context.function import FunctionMixin -from jedi.evaluate.context import iterable -from jedi.evaluate.lazy_context import LazyTreeContext, LazyKnownContext, \ +from jedi.inference.context.klass import ClassMixin +from jedi.inference.context.function import FunctionMixin +from jedi.inference.context import iterable +from jedi.inference.lazy_context import LazyTreeContext, LazyKnownContext, \ LazyKnownContexts -from jedi.evaluate.names import ContextName, BaseTreeParamName -from jedi.evaluate.syntax_tree import is_string -from jedi.evaluate.filters import AttributeOverwrite, publish_method, \ +from jedi.inference.names import ContextName, BaseTreeParamName +from jedi.inference.syntax_tree import is_string +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. diff --git a/jedi/refactoring.py b/jedi/refactoring.py index 6c1d74d1..996c67ba 100644 --- a/jedi/refactoring.py +++ b/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): diff --git a/test/completion/generators.py b/test/completion/generators.py index ee541df1..1d5e5384 100644 --- a/test/completion/generators.py +++ b/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 diff --git a/test/completion/sys_path.py b/test/completion/sys_path.py index 890f2fe2..1346b22e 100644 --- a/test/completion/sys_path.py +++ b/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'] -import evaluate +#? ['inference'] +import inference #? ['evaluator_function_cache'] -evaluate.Evaluator_fu +inference.Evaluator_fu # Those don't work because dirname and abspath are not properly understood. ##? ['jedi_'] diff --git a/test/completion/thirdparty/jedi_.py b/test/completion/thirdparty/jedi_.py index dc384b1f..59f21f75 100644 --- a/test/completion/thirdparty/jedi_.py +++ b/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() -list(evaluate.follow_call())[0] +#? inference.Array() inference.Class() inference.Function() inference.Instance() +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() -evaluate.get_scopes_for_name()[0] +#? inference.Class() inference.Function() +inference.get_scopes_for_name()[0] diff --git a/test/conftest.py b/test/conftest.py index 45bb48e0..d1703893 100644 --- a/test/conftest.py +++ b/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): diff --git a/test/run.py b/test/run.py index 9e87be27..552a96d6 100755 --- a/test/run.py +++ b/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 diff --git a/test/test_api/test_api.py b/test/test_api/test_api.py index af7b9e7e..e8f3f2dc 100644 --- a/test/test_api/test_api.py +++ b/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(): diff --git a/test/test_api/test_classes.py b/test/test_api/test_classes.py index d7449711..b8702d47 100644 --- a/test/test_api/test_classes.py +++ b/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): diff --git a/test/test_api/test_completion.py b/test/test_api/test_completion.py index 865ed7a1..f446d78a 100644 --- a/test/test_api/test_completion.py +++ b/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. """ diff --git a/test/test_api/test_interpreter.py b/test/test_api/test_interpreter.py index e97f4985..02e49946 100644 --- a/test/test_api/test_interpreter.py +++ b/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: diff --git a/test/test_api/test_settings.py b/test/test_api/test_settings.py index 24ae05fe..492718a6 100644 --- a/test/test_api/test_settings.py +++ b/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 diff --git a/test/test_inference/test_buildout_detection.py b/test/test_inference/test_buildout_detection.py index 622ded23..e90e1ee1 100644 --- a/test/test_inference/test_buildout_detection.py +++ b/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) diff --git a/test/test_inference/test_compiled.py b/test/test_inference/test_compiled.py index fdf349bf..49871014 100644 --- a/test/test_inference/test_compiled.py +++ b/test/test_inference/test_compiled.py @@ -6,9 +6,9 @@ from datetime import datetime import pytest -from jedi.evaluate import compiled -from jedi.evaluate.compiled.access import DirectObjectAccess -from jedi.evaluate.gradual.conversion import _stub_to_python_context_set +from jedi.inference import compiled +from jedi.inference.compiled.access import DirectObjectAccess +from jedi.inference.gradual.conversion import _stub_to_python_context_set def test_simple(evaluator, environment): diff --git a/test/test_inference/test_gradual/test_typeshed.py b/test/test_inference/test_gradual/test_typeshed.py index 4cd485a8..d40f020f 100644 --- a/test/test_inference/test_gradual/test_typeshed.py +++ b/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.evaluate.context import TreeInstance, BoundMethod, FunctionContext, \ +from jedi.inference.gradual import typeshed, stub_context +from jedi.inference.context import TreeInstance, BoundMethod, FunctionContext, \ MethodContext, ClassContext TYPESHED_PYTHON3 = os.path.join(typeshed.TYPESHED_PATH, 'stdlib', '3') diff --git a/test/test_inference/test_helpers.py b/test/test_inference/test_helpers.py index 65dd01cb..adfb4221 100644 --- a/test/test_inference/test_helpers.py +++ b/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): diff --git a/test/test_inference/test_imports.py b/test/test_inference/test_imports.py index b0eef6d0..1babc5aa 100644 --- a/test/test_inference/test_imports.py +++ b/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.evaluate import imports +from jedi.inference import compiled +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__) diff --git a/test/test_inference/test_literals.py b/test/test_inference/test_literals.py index dd72f8e8..68b4ffa2 100644 --- a/test/test_inference/test_literals.py +++ b/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): diff --git a/test/test_inference/test_precedence.py b/test/test_inference/test_precedence.py index 2e97119e..9861494a 100644 --- a/test/test_inference/test_precedence.py +++ b/test/test_inference/test_precedence.py @@ -1,4 +1,4 @@ -from jedi.evaluate.compiled import CompiledObject +from jedi.inference.compiled import CompiledObject import pytest diff --git a/test/test_inference/test_signature.py b/test/test_inference/test_signature.py index 0bb5cbae..6b917197 100644 --- a/test/test_inference/test_signature.py +++ b/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( diff --git a/test/test_inference/test_sys_path.py b/test/test_inference/test_sys_path.py index deaa64ca..67b8d87e 100644 --- a/test/test_inference/test_sys_path.py +++ b/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 diff --git a/test/test_settings.py b/test/test_settings.py index e97b2fa3..bc0b0186 100644 --- a/test/test_settings.py +++ b/test/test_settings.py @@ -1,9 +1,9 @@ import pytest from jedi import settings -from jedi.evaluate.names import ContextName -from jedi.evaluate.compiled import CompiledContextName -from jedi.evaluate.gradual.typeshed import StubModuleContext +from jedi.inference.names import ContextName +from jedi.inference.compiled import CompiledContextName +from jedi.inference.gradual.typeshed import StubModuleContext @pytest.fixture()