VimPlug/jedi
1
0
Fork 1
mirror of https://github.com/davidhalter/jedi.git synced 2026-01-01 09:43:21 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Better working flow scopes.

Browse Source
This commit is contained in:
Dave Halter
2016-10-28 00:36:17 +02:00
parent a620c7dbdb
commit bbb1d1e04c
4 changed files with 27 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
jedi/evaluate/flow_analysis.py
View File

@@ -32,9 +32,8 @@ UNREACHABLE = Status(False, 'unreachable')
UNSURE = Status(None, 'unsure')
def break_check(evaluator, base_scope, stmt, origin_scope=None):
raise NotImplementedError
element_scope = evaluator.wrap(stmt.get_parent_scope(include_flows=True))
def reachability_check(context, context_scope, node, origin_scope=None):
flow_scope = node.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
@@ -43,48 +42,47 @@ def break_check(evaluator, base_scope, stmt, origin_scope=None):
# unaccessible. This is not a "problem" in Python, because the code is
# never called. In Jedi though, we still want to infer types.
while origin_scope is not None:
if element_scope == origin_scope:
if flow_scope == origin_scope:
return REACHABLE
origin_scope = origin_scope.parent
x = _break_check(evaluator, stmt, base_scope, element_scope)
return x
return _break_check(context, context_scope, flow_scope, node)
def _break_check(evaluator, stmt, base_scope, element_scope):
element_scope = evaluator.wrap(element_scope)
base_scope = evaluator.wrap(base_scope)
def _break_check(context, context_scope, flow_scope, node):
reachable = REACHABLE
if isinstance(element_scope, tree.IfStmt):
if element_scope.node_after_else(stmt):
for check_node in element_scope.check_nodes():
reachable = _check_if(evaluator, check_node)
if flow_scope.type == 'if_stmt':
if flow_scope.node_after_else(node):
for check_node in flow_scope.check_nodes():
reachable = _check_if(context, check_node)
if reachable in (REACHABLE, UNSURE):
break
reachable = reachable.invert()
else:
node = element_scope.node_in_which_check_node(stmt)
node = flow_scope.node_in_which_check_node(node)
if node is not None:
reachable = _check_if(evaluator, node)
elif isinstance(element_scope, (tree.TryStmt, tree.WhileStmt)):
reachable = _check_if(context, node)
elif flow_scope.type in ('try_stmt', 'while_stmt'):
return UNSURE
# Only reachable branches need to be examined further.
if reachable in (UNREACHABLE, UNSURE):
return reachable
if element_scope.type == 'file_input':
# TODO REMOVE WTF
#if element_scope.type == 'file_input':
# The definition is in another module and therefore just return what we
# have generated.
return reachable
if base_scope != element_scope and base_scope != element_scope.parent:
return reachable & _break_check(evaluator, stmt, base_scope, element_scope.parent)
# return reachable
if context_scope != flow_scope and context_scope != flow_scope.parent:
flow_scope = flow_scope.get_parent_scope(include_flows=True)
return reachable & _break_check(context, context_scope, flow_scope, node)
else:
return reachable
def _check_if(evaluator, node):
types = evaluator.eval_element(node)
def _check_if(context, node):
types = context.eval_node(node)
values = set(x.py__bool__() for x in types)
if len(values) == 1:
return Status.lookup_table[values.pop()]