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

er.wrap -> Evaluator.wrap

Browse Source
This commit is contained in:
Dave Halter
2015-04-23 13:51:42 +02:00
parent ed74dde45c
commit d038fba9df
8 changed files with 31 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
jedi/api/__init__.py
View File

@@ -113,7 +113,7 @@ class Script(object):
debug.speed('init') debug.speed('init')
def _parsed_callback(self, parser): def _parsed_callback(self, parser):
module = er.wrap(self._evaluator, parser.module) module = self._evaluator.wrap(parser.module)
self._evaluator.modules[unicode(module.name)] = module self._evaluator.modules[unicode(module.name)] = module
@property @property
@@ -213,7 +213,7 @@ class Script(object):
if isinstance(c.parent, (pr.Function, pr.Class)): if isinstance(c.parent, (pr.Function, pr.Class)):
# TODO I think this is a hack. It should be an # TODO I think this is a hack. It should be an
# er.Function/er.Class before that. # er.Function/er.Class before that.
c = er.wrap(self._evaluator, c.parent).name c = self._evaluator.wrap(c.parent).name
new = classes.Completion(self._evaluator, c, needs_dot, len(like)) new = classes.Completion(self._evaluator, c, needs_dot, len(like))
k = (new.name, new.complete) # key k = (new.name, new.complete) # key
if k in comp_dct and settings.no_completion_duplicates: if k in comp_dct and settings.no_completion_duplicates:
@@ -235,7 +235,7 @@ class Script(object):
scope = scope.get_parent_scope() scope = scope.get_parent_scope()
names_dicts = global_names_dict_generator( names_dicts = global_names_dict_generator(
self._evaluator, self._evaluator,
er.wrap(self._evaluator, scope), self._evaluator.wrap(scope),
self._pos self._pos
) )
completion_names = [] completion_names = []
@@ -342,7 +342,7 @@ class Script(object):
context = self._user_context.get_context() context = self._user_context.get_context()
definitions = set() definitions = set()
if next(context) in ('class', 'def'): if next(context) in ('class', 'def'):
definitions = set([er.wrap(self._evaluator, self._parser.user_scope())]) definitions = set([self._evaluator.wrap(self._parser.user_scope())])
else: else:
# Fetch definition of callee, if there's no path otherwise. # Fetch definition of callee, if there's no path otherwise.
if not goto_path: if not goto_path:

5
jedi/api/classes.py
View File

@@ -61,7 +61,7 @@ class BaseDefinition(object):
""" """
An instance of :class:`jedi.parser.reprsentation.Name` subclass. An instance of :class:`jedi.parser.reprsentation.Name` subclass.
""" """
self._definition = er.wrap(evaluator, self._name.get_definition()) self._definition = evaluator.wrap(self._name.get_definition())
self.is_keyword = isinstance(self._definition, keywords.Keyword) self.is_keyword = isinstance(self._definition, keywords.Keyword)
# generate a path to the definition # generate a path to the definition
@@ -175,7 +175,6 @@ class BaseDefinition(object):
pass pass
else: else:
if isinstance(par, er.ModuleWrapper): if isinstance(par, er.ModuleWrapper):
#module = er.wrap(self._evaluator, par)
# TODO just make the path dotted from the beginning, we # TODO just make the path dotted from the beginning, we
# shouldn't really split here. # shouldn't really split here.
path[0:0] = par.py__name__().split('.') path[0:0] = par.py__name__().split('.')
@@ -354,7 +353,7 @@ class BaseDefinition(object):
def parent(self): def parent(self):
scope = self._definition.get_parent_scope() scope = self._definition.get_parent_scope()
scope = er.wrap(self._evaluator, scope) scope = self._evaluator.wrap(scope)
return Definition(self._evaluator, scope.name) return Definition(self._evaluator, scope.name)
def __repr__(self): def __repr__(self):

2
jedi/api/interpreter.py
View File

@@ -85,7 +85,7 @@ class LazyName(helpers.FakeName):
assert len(parser_path) == 1 assert len(parser_path) == 1
found = self._evaluator.find_types(mod, parser_path[0], search_global=True) found = self._evaluator.find_types(mod, parser_path[0], search_global=True)
else: else:
found = [er.wrap(self._evaluator, mod)] found = [self._evaluator.wrap(mod)]
if not found: if not found:
debug.warning('Possibly an interpreter lookup for Python code failed %s', debug.warning('Possibly an interpreter lookup for Python code failed %s',

15
jedi/evaluate/__init__.py
View File

@@ -91,7 +91,18 @@ class Evaluator(object):
self.analysis = [] self.analysis = []
def wrap(self, element): def wrap(self, element):
return er.wrap(self, element) if isinstance(element, pr.Class):
return er.Class(self, element)
elif isinstance(element, pr.Function):
if isinstance(element, pr.Lambda):
return er.LambdaWrapper(self, element)
else:
return er.Function(self, element)
elif isinstance(element, (pr.Module)) \
and not isinstance(element, er.ModuleWrapper):
return er.ModuleWrapper(self, element)
else:
return element
def find_types(self, scope, name_str, position=None, search_global=False, def find_types(self, scope, name_str, position=None, search_global=False,
is_goto=False): is_goto=False):
@@ -133,7 +144,7 @@ class Evaluator(object):
operator = copy.copy(first_operation) operator = copy.copy(first_operation)
operator.value = operator.value[:-1] operator.value = operator.value[:-1]
name = str(stmt.get_defined_names()[0]) name = str(stmt.get_defined_names()[0])
parent = er.wrap(self, stmt.get_parent_scope()) parent = self.wrap(stmt.get_parent_scope())
left = self.find_types(parent, name, stmt.start_pos, search_global=True) left = self.find_types(parent, name, stmt.start_pos, search_global=True)
if isinstance(stmt.get_parent_until(pr.ForStmt), pr.ForStmt): if isinstance(stmt.get_parent_until(pr.ForStmt), pr.ForStmt):
# Iterate through result and add the values, that's possible # Iterate through result and add the values, that's possible

2
jedi/evaluate/dynamic.py
View File

@@ -112,7 +112,7 @@ def search_function_call(evaluator, func):
else: else:
undec.append(escope) undec.append(escope)
if er.wrap(evaluator, compare) in undec: if evaluator.wrap(compare) in undec:
# Only if we have the correct function we execute # Only if we have the correct function we execute
# it, otherwise just ignore it. # it, otherwise just ignore it.
evaluator.eval_trailer(types, trailer) evaluator.eval_trailer(types, trailer)

12
jedi/evaluate/finder.py
View File

@@ -76,7 +76,7 @@ class NameFinder(object):
def __init__(self, evaluator, scope, name_str, position=None): def __init__(self, evaluator, scope, name_str, position=None):
self._evaluator = evaluator self._evaluator = evaluator
# Make sure that it's not just a syntax tree node. # Make sure that it's not just a syntax tree node.
self.scope = er.wrap(evaluator, scope) self.scope = evaluator.wrap(scope)
self.name_str = name_str self.name_str = name_str
self.position = position self.position = position
@@ -129,7 +129,7 @@ class NameFinder(object):
last_names = [] last_names = []
for name in reversed(sorted(names, key=lambda name: name.start_pos)): for name in reversed(sorted(names, key=lambda name: name.start_pos)):
stmt = name.get_definition() stmt = name.get_definition()
name_scope = er.wrap(self._evaluator, stmt.get_parent_scope()) name_scope = self._evaluator.wrap(stmt.get_parent_scope())
if isinstance(self.scope, er.Instance) and not isinstance(name_scope, er.Instance): if isinstance(self.scope, er.Instance) and not isinstance(name_scope, er.Instance):
# Instances should not be checked for positioning, because we # Instances should not be checked for positioning, because we
@@ -191,7 +191,7 @@ class NameFinder(object):
for n in names: for n in names:
definition = n.parent definition = n.parent
if isinstance(definition, (pr.Function, pr.Class, pr.Module)): if isinstance(definition, (pr.Function, pr.Class, pr.Module)):
yield er.wrap(self._evaluator, definition).name yield self._evaluator.wrap(definition).name
else: else:
yield n yield n
@@ -344,7 +344,7 @@ def _eval_param(evaluator, param, scope):
if isinstance(scope, er.InstanceElement): if isinstance(scope, er.InstanceElement):
res_new.append(scope.instance) res_new.append(scope.instance)
else: else:
inst = er.Instance(evaluator, er.wrap(evaluator, cls), inst = er.Instance(evaluator, evaluator.wrap(cls),
Arguments(evaluator, ()), is_generated=True) Arguments(evaluator, ()), is_generated=True)
res_new.append(inst) res_new.append(inst)
return res_new return res_new
@@ -464,7 +464,7 @@ def global_names_dict_generator(evaluator, scope, position):
>>> from jedi.evaluate import Evaluator >>> from jedi.evaluate import Evaluator
>>> evaluator = Evaluator(load_grammar()) >>> evaluator = Evaluator(load_grammar())
>>> scope = er.wrap(evaluator, scope) >>> scope = evaluator.wrap(scope)
>>> pairs = list(global_names_dict_generator(evaluator, scope, (4, 0))) >>> pairs = list(global_names_dict_generator(evaluator, scope, (4, 0)))
>>> no_unicode_pprint(pairs[0]) >>> no_unicode_pprint(pairs[0])
({'func': [], 'y': [<Name: y@4,4>]}, (4, 0)) ({'func': [], 'y': [<Name: y@4,4>]}, (4, 0))
@@ -503,7 +503,7 @@ def global_names_dict_generator(evaluator, scope, position):
# The position should be reset if the current scope is a function. # The position should be reset if the current scope is a function.
in_func = True in_func = True
position = None position = None
scope = er.wrap(evaluator, scope.get_parent_scope()) scope = evaluator.wrap(scope.get_parent_scope())
# Add builtins to the global scope. # Add builtins to the global scope.
for names_dict in compiled.builtin.names_dicts(True): for names_dict in compiled.builtin.names_dicts(True):

8
jedi/evaluate/flow_analysis.py
View File

@@ -33,8 +33,7 @@ UNSURE = Status(None, 'unsure')
def break_check(evaluator, base_scope, stmt, origin_scope=None): def break_check(evaluator, base_scope, stmt, origin_scope=None):
from jedi.evaluate.representation import wrap element_scope = evaluator.wrap(stmt.get_parent_scope(include_flows=True))
element_scope = wrap(evaluator, stmt.get_parent_scope(include_flows=True))
# Direct parents get resolved, we filter scopes that are separate branches. # Direct parents get resolved, we filter scopes that are separate branches.
# This makes sense for autocompletion and static analysis. For actual # This makes sense for autocompletion and static analysis. For actual
# Python it doesn't matter, because we're talking about potentially # Python it doesn't matter, because we're talking about potentially
@@ -50,9 +49,8 @@ def break_check(evaluator, base_scope, stmt, origin_scope=None):
def _break_check(evaluator, stmt, base_scope, element_scope): def _break_check(evaluator, stmt, base_scope, element_scope):
from jedi.evaluate.representation import wrap element_scope = evaluator.wrap(element_scope)
element_scope = wrap(evaluator, element_scope) base_scope = evaluator.wrap(base_scope)
base_scope = wrap(evaluator, base_scope)
reachable = REACHABLE reachable = REACHABLE
if isinstance(element_scope, pr.IfStmt): if isinstance(element_scope, pr.IfStmt):

17
jedi/evaluate/representation.py
View File

@@ -50,21 +50,6 @@ from jedi.evaluate import flow_analysis
from jedi.evaluate import imports from jedi.evaluate import imports
def wrap(evaluator, element):
if isinstance(element, pr.Class):
return Class(evaluator, element)
elif isinstance(element, pr.Function):
if isinstance(element, pr.Lambda):
return LambdaWrapper(evaluator, element)
else:
return Function(evaluator, element)
elif isinstance(element, (pr.Module)) \
and not isinstance(element, ModuleWrapper):
return ModuleWrapper(evaluator, element)
else:
return element
class Executed(pr.Base): class Executed(pr.Base):
""" """
An instance is also an executable - because __init__ is called An instance is also an executable - because __init__ is called
@@ -290,7 +275,7 @@ def get_instance_el(evaluator, instance, var, is_class_var=False):
pr.Module, FunctionExecution)): pr.Module, FunctionExecution)):
return var return var
var = wrap(evaluator, var) var = evaluator.wrap(var)
return InstanceElement(evaluator, instance, var, is_class_var) return InstanceElement(evaluator, instance, var, is_class_var)