From 2e33394adb117e3f955a04d90a7e5cf653d31486 Mon Sep 17 00:00:00 2001 From: Dave Halter Date: Thu, 19 May 2016 10:40:22 +0200 Subject: [PATCH] Move the type inference call of the api to inference.py --- jedi/api/__init__.py | 52 +++++++++---------------------------------- jedi/api/inference.py | 40 ++++++++++++++++++++++++++++++++- 2 files changed, 49 insertions(+), 43 deletions(-) diff --git a/jedi/api/__init__.py b/jedi/api/__init__.py index e8ce4e05..bcd4db05 100644 --- a/jedi/api/__init__.py +++ b/jedi/api/__init__.py @@ -13,7 +13,7 @@ import sys import collections from itertools import chain -from jedi._compatibility import unicode, builtins +from jedi._compatibility import unicode from jedi.parser import load_grammar from jedi.parser import tree from jedi.parser.user_context import UserContext, UserContextParser @@ -32,7 +32,7 @@ from jedi.evaluate import representation as er from jedi.evaluate import compiled from jedi.evaluate import imports from jedi.evaluate.param import try_iter_content -from jedi.evaluate.helpers import FakeName, get_module_names +from jedi.evaluate.helpers import get_module_names from jedi.evaluate.finder import global_names_dict_generator, filter_definition_names from jedi.evaluate.sys_path import get_venv_path from jedi.evaluate.iterable import unpack_tuple_to_dict @@ -273,7 +273,10 @@ class Script(object): path, self._pos) is None: return [] else: - scopes = list(self._type_inference(path, True)) + scopes = list(inference.type_inference( + self._evaluator, self._parser, self._user_context, + self._pos, path, is_completion=True + )) completion_names = [] debug.dbg('possible completion scopes: %s', scopes) for s in scopes: @@ -284,44 +287,6 @@ class Script(object): completion_names += filter_definition_names(names, self._parser.user_stmt()) return completion_names - def _type_inference(self, dotted_path, is_completion=False): - """ - Base for completions/goto. Basically it returns the resolved scopes - under cursor. - """ - debug.dbg('start: %s in %s', dotted_path, self._parser.user_scope()) - - user_stmt = self._parser.user_stmt_with_whitespace() - if not user_stmt and len(dotted_path.split('\n')) > 1: - # If the user_stmt is not defined and the dotted_path is multi line, - # something's strange. Most probably the backwards tokenizer - # matched to much. - return [] - - if isinstance(user_stmt, tree.Import): - i, _ = helpers.get_on_import_stmt(self._evaluator, self._user_context, - user_stmt, is_completion) - if i is None: - return [] - scopes = [i] - else: - # Just parse one statement, take it and evaluate it. - eval_stmt = inference.get_under_cursor_stmt(self._evaluator, - self._parser, dotted_path, self._pos) - if eval_stmt is None: - return [] - - module = self._evaluator.wrap(self._parser.module()) - names, level, _, _ = helpers.check_error_statements(module, self._pos) - if names: - names = [str(n) for n in names] - i = imports.Importer(self._evaluator, names, module, level) - return i.follow() - - scopes = self._evaluator.eval_element(eval_stmt) - - return scopes - def goto_definitions(self): """ Return the definitions of a the path under the cursor. goto function! @@ -363,7 +328,10 @@ class Script(object): definitions = self._evaluator.goto_definition(name) if not definitions and goto_path: - definitions = self._type_inference(goto_path) + definitions = inference.type_inference( + self._evaluator, self._parser, self._user_context, + self._pos, goto_path + ) definitions = resolve_import_paths(definitions) names = [s.name for s in definitions] diff --git a/jedi/api/inference.py b/jedi/api/inference.py index 09a96e27..56bf4e55 100644 --- a/jedi/api/inference.py +++ b/jedi/api/inference.py @@ -2,12 +2,50 @@ This module has helpers for doing type inference on strings. It is needed, because we still want to infer types where the syntax is invalid. """ +from jedi import debug +from jedi.api import helpers +from jedi.parser import tree from jedi.parser import Parser, ParseError +from jedi.evaluate import imports from jedi.evaluate.cache import memoize_default def type_inference(evaluator, parser, user_context, position, dotted_path, is_completion=False): - pass + """ + Base for completions/goto. Basically it returns the resolved scopes + under cursor. + """ + debug.dbg('start: %s in %s', dotted_path, parser.user_scope()) + + user_stmt = parser.user_stmt_with_whitespace() + if not user_stmt and len(dotted_path.split('\n')) > 1: + # If the user_stmt is not defined and the dotted_path is multi line, + # something's strange. Most probably the backwards tokenizer + # matched to much. + return [] + + if isinstance(user_stmt, tree.Import): + i, _ = helpers.get_on_import_stmt(evaluator, user_context, + user_stmt, is_completion) + if i is None: + return [] + scopes = [i] + else: + # Just parse one statement, take it and evaluate it. + eval_stmt = get_under_cursor_stmt(evaluator, parser, dotted_path, position) + if eval_stmt is None: + return [] + + module = evaluator.wrap(parser.module()) + names, level, _, _ = helpers.check_error_statements(module, position) + if names: + names = [str(n) for n in names] + i = imports.Importer(evaluator, names, module, level) + return i.follow() + + scopes = evaluator.eval_element(eval_stmt) + + return scopes @memoize_default(evaluator_is_first_arg=True)