VimPlug/jedi-fork
1
0
Fork 0
forked from VimPlug/jedi
Code Pull Requests Activity

context -> value

Browse Source
This commit is contained in:
Dave Halter
2019-08-15 01:23:06 +02:00
parent 9e23f4d67b
commit ad4f546aca
68 changed files with 1931 additions and 1931 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jedi/inference/names.py
+42 -42
View File
@@ -10,9 +10,9 @@ from jedi.cache import memoize_method
class AbstractNameDefinition(object):
start_pos = None
string_name = None
parent_context = None
parent_value = None
tree_name = None
is_context_name = True
is_value_name = True
"""
Used for the Jedi API to know if it's a keyword or an actual name.
"""
@@ -32,7 +32,7 @@ class AbstractNameDefinition(object):
if qualified_names is None or not include_module_names:
return qualified_names
module_names = self.get_root_context().string_names
module_names = self.get_root_value().string_names
if module_names is None:
return None
return module_names + qualified_names
@@ -41,8 +41,8 @@ class AbstractNameDefinition(object):
# By default, a name has no qualified names.
return None
def get_root_context(self):
return self.parent_context.get_root_context()
def get_root_value(self):
return self.parent_value.get_root_value()
def __repr__(self):
if self.start_pos is None:
@@ -55,7 +55,7 @@ class AbstractNameDefinition(object):
@property
def api_type(self):
return self.parent_context.api_type
return self.parent_value.api_type
class AbstractArbitraryName(AbstractNameDefinition):
@@ -64,20 +64,20 @@ class AbstractArbitraryName(AbstractNameDefinition):
string literals, which is not really a name, but for Jedi we use this
concept of Name for completions as well.
"""
is_context_name = False
is_value_name = False
def __init__(self, infer_state, string):
self.infer_state = infer_state
self.string_name = string
self.parent_context = infer_state.builtins_module
self.parent_value = infer_state.builtins_module
def infer(self):
return NO_CONTEXTS
class AbstractTreeName(AbstractNameDefinition):
def __init__(self, parent_context, tree_name):
self.parent_context = parent_context
def __init__(self, parent_value, tree_name):
self.parent_value = parent_value
self.tree_name = tree_name
def get_qualified_names(self, include_module_names=False):
@@ -87,7 +87,7 @@ class AbstractTreeName(AbstractNameDefinition):
# In case of level == 1, it works always, because it's like a submodule
# lookup.
if import_node is not None and not (import_node.level == 1
and self.get_root_context().is_package):
and self.get_root_value().is_package):
# TODO improve the situation for when level is present.
if include_module_names and not import_node.level:
return tuple(n.value for n in import_node.get_path_for_name(self.tree_name))
@@ -97,13 +97,13 @@ class AbstractTreeName(AbstractNameDefinition):
return super(AbstractTreeName, self).get_qualified_names(include_module_names)
def _get_qualified_names(self):
parent_names = self.parent_context.get_qualified_names()
parent_names = self.parent_value.get_qualified_names()
if parent_names is None:
return None
return parent_names + (self.tree_name.value,)
def goto(self, **kwargs):
return self.parent_context.infer_state.goto(self.parent_context, self.tree_name, **kwargs)
return self.parent_value.infer_state.goto(self.parent_value, self.tree_name, **kwargs)
def is_import(self):
imp = search_ancestor(self.tree_name, 'import_from', 'import_name')
@@ -120,28 +120,28 @@ class AbstractTreeName(AbstractNameDefinition):
class ContextNameMixin(object):
def infer(self):
return ContextSet([self._context])
return ContextSet([self._value])
def _get_qualified_names(self):
return self._context.get_qualified_names()
return self._value.get_qualified_names()
def get_root_context(self):
if self.parent_context is None: # A module
return self._context
return super(ContextNameMixin, self).get_root_context()
def get_root_value(self):
if self.parent_value is None: # A module
return self._value
return super(ContextNameMixin, self).get_root_value()
@property
def api_type(self):
return self._context.api_type
return self._value.api_type
class ContextName(ContextNameMixin, AbstractTreeName):
def __init__(self, context, tree_name):
super(ContextName, self).__init__(context.parent_context, tree_name)
self._context = context
def __init__(self, value, tree_name):
super(ContextName, self).__init__(value.parent_value, tree_name)
self._value = value
def goto(self):
return ContextSet([self._context.name])
return ContextSet([self._value.name])
class TreeNameDefinition(AbstractTreeName):
@@ -155,9 +155,9 @@ class TreeNameDefinition(AbstractTreeName):
def infer(self):
# Refactor this, should probably be here.
from jedi.inference.syntax_tree import tree_name_to_contexts
parent = self.parent_context
return tree_name_to_contexts(parent.infer_state, parent, self.tree_name)
from jedi.inference.syntax_tree import tree_name_to_values
parent = self.parent_value
return tree_name_to_values(parent.infer_state, parent, self.tree_name)
@property
def api_type(self):
@@ -241,16 +241,16 @@ class ParamName(BaseTreeParamName):
node = self.annotation_node
if node is None:
return NO_CONTEXTS
contexts = self.parent_context.parent_context.infer_node(node)
values = self.parent_value.parent_value.infer_node(node)
if execute_annotation:
contexts = contexts.execute_annotation()
return contexts
values = values.execute_annotation()
return values
def infer_default(self):
node = self.default_node
if node is None:
return NO_CONTEXTS
return self.parent_context.parent_context.infer_node(node)
return self.parent_value.parent_value.infer_node(node)
@property
def default_node(self):
@@ -297,7 +297,7 @@ class ParamName(BaseTreeParamName):
return self.get_param().infer()
def get_param(self):
params, _ = self.parent_context.get_executed_params_and_issues()
params, _ = self.parent_value.get_executed_params_and_issues()
param_node = search_ancestor(self.tree_name, 'param')
return params[param_node.position_index]
@@ -317,15 +317,15 @@ class ImportName(AbstractNameDefinition):
start_pos = (1, 0)
_level = 0
def __init__(self, parent_context, string_name):
self._from_module_context = parent_context
def __init__(self, parent_value, string_name):
self._from_module_value = parent_value
self.string_name = string_name
def get_qualified_names(self, include_module_names=False):
if include_module_names:
if self._level:
assert self._level == 1, "Everything else is not supported for now"
module_names = self._from_module_context.string_names
module_names = self._from_module_value.string_names
if module_names is None:
return module_names
return module_names + (self.string_name,)
@@ -333,19 +333,19 @@ class ImportName(AbstractNameDefinition):
return ()
@property
def parent_context(self):
m = self._from_module_context
import_contexts = self.infer()
if not import_contexts:
def parent_value(self):
m = self._from_module_value
import_values = self.infer()
if not import_values:
return m
# It's almost always possible to find the import or to not find it. The
# importing returns only one context, pretty much always.
return next(iter(import_contexts))
# importing returns only one value, pretty much always.
return next(iter(import_values))
@memoize_method
def infer(self):
from jedi.inference.imports import Importer
m = self._from_module_context
m = self._from_module_value
return Importer(m.infer_state, [self.string_name], m, level=self._level).follow()
def goto(self):