VimPlug/jedi
1
0
Fork 1
mirror of https://github.com/davidhalter/jedi.git synced 2025-12-15 18:17:07 +08:00
Code Issues Actions Packages Projects Releases Wiki 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')
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
@property
@@ -213,7 +213,7 @@ class Script(object):
if isinstance(c.parent, (pr.Function, pr.Class)):
# TODO I think this is a hack. It should be an
# 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))
k = (new.name, new.complete) # key
if k in comp_dct and settings.no_completion_duplicates:
@@ -235,7 +235,7 @@ class Script(object):
scope = scope.get_parent_scope()
names_dicts = global_names_dict_generator(
self._evaluator,
er.wrap(self._evaluator, scope),
self._evaluator.wrap(scope),
self._pos
)
completion_names = []
@@ -342,7 +342,7 @@ class Script(object):
context = self._user_context.get_context()
definitions = set()
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:
# Fetch definition of callee, if there's no path otherwise.
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.
"""
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)
# generate a path to the definition
@@ -175,7 +175,6 @@ class BaseDefinition(object):
pass
else:
if isinstance(par, er.ModuleWrapper):
#module = er.wrap(self._evaluator, par)
# TODO just make the path dotted from the beginning, we
# shouldn't really split here.
path[0:0] = par.py__name__().split('.')
@@ -354,7 +353,7 @@ class BaseDefinition(object):
def parent(self):
scope = self._definition.get_parent_scope()
scope = er.wrap(self._evaluator, scope)
scope = self._evaluator.wrap(scope)
return Definition(self._evaluator, scope.name)
def __repr__(self):

2
jedi/api/interpreter.py
View File

@@ -85,7 +85,7 @@ class LazyName(helpers.FakeName):
assert len(parser_path) == 1
found = self._evaluator.find_types(mod, parser_path[0], search_global=True)
else:
found = [er.wrap(self._evaluator, mod)]
found = [self._evaluator.wrap(mod)]
if not found:
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 = []
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,
is_goto=False):
@@ -133,7 +144,7 @@ class Evaluator(object):
operator = copy.copy(first_operation)
operator.value = operator.value[:-1]
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)
if isinstance(stmt.get_parent_until(pr.ForStmt), pr.ForStmt):
# 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:
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
# it, otherwise just ignore it.
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):
self._evaluator = evaluator
# 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.position = position
@@ -129,7 +129,7 @@ class NameFinder(object):
last_names = []
for name in reversed(sorted(names, key=lambda name: name.start_pos)):
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):
# Instances should not be checked for positioning, because we
@@ -191,7 +191,7 @@ class NameFinder(object):
for n in names:
definition = n.parent
if isinstance(definition, (pr.Function, pr.Class, pr.Module)):
yield er.wrap(self._evaluator, definition).name
yield self._evaluator.wrap(definition).name
else:
yield n
@@ -344,7 +344,7 @@ def _eval_param(evaluator, param, scope):
if isinstance(scope, er.InstanceElement):
res_new.append(scope.instance)
else:
inst = er.Instance(evaluator, er.wrap(evaluator, cls),
inst = er.Instance(evaluator, evaluator.wrap(cls),
Arguments(evaluator, ()), is_generated=True)
res_new.append(inst)
return res_new
@@ -464,7 +464,7 @@ def global_names_dict_generator(evaluator, scope, position):
>>> from jedi.evaluate import Evaluator
>>> evaluator = Evaluator(load_grammar())
>>> scope = er.wrap(evaluator, scope)
>>> scope = evaluator.wrap(scope)
>>> pairs = list(global_names_dict_generator(evaluator, scope, (4, 0)))
>>> no_unicode_pprint(pairs[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.
in_func = True
position = None
scope = er.wrap(evaluator, scope.get_parent_scope())
scope = evaluator.wrap(scope.get_parent_scope())
# Add builtins to the global scope.
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):
from jedi.evaluate.representation import wrap
element_scope = wrap(evaluator, stmt.get_parent_scope(include_flows=True))
element_scope = evaluator.wrap(stmt.get_parent_scope(include_flows=True))
# Direct parents get resolved, we filter scopes that are separate branches.
# This makes sense for autocompletion and static analysis. For actual
# 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):
from jedi.evaluate.representation import wrap
element_scope = wrap(evaluator, element_scope)
base_scope = wrap(evaluator, base_scope)
element_scope = evaluator.wrap(element_scope)
base_scope = evaluator.wrap(base_scope)
reachable = REACHABLE
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
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):
"""
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)):
return var
var = wrap(evaluator, var)
var = evaluator.wrap(var)
return InstanceElement(evaluator, instance, var, is_class_var)