VimPlug/jedi
1
0
Fork 1
mirror of https://github.com/davidhalter/jedi.git synced 2025-12-16 02:27:06 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move error recovery function.

Browse Source
This commit is contained in:
Dave Halter
2014-11-02 17:24:06 +01:00
parent 0c3cba166e
commit 1ff4713848
4 changed files with 52 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
jedi/evaluate/finder.py
View File

@@ -65,6 +65,13 @@ class NameFinder(object):
return iter([(self.scope, self.scope.get_magic_function_names())])
return self.scope.scope_names_generator(self.position)
def names_dict_lookup(self, scope):
try:
names = scope.names_dict[str(self.name_str)]
except KeyError:
return []
return [name for name in names if name.is_definition()]
def filter_name(self, scope_names_generator, search_global=False):
"""
Filters all variables of a scope (which are defined in the
@@ -76,7 +83,12 @@ class NameFinder(object):
names = []
self.maybe_descriptor = isinstance(self.scope, er.Class)
for name_list_scope, name_list in scope_names_generator:
print(name_list_scope, hasattr(name_list_scope, 'names_dict'))
if hasattr(name_list_scope, 'names_dict'):
names = self.names_dict_lookup(name_list_scope)
if names:
break
continue
break_scopes = []
if not isinstance(name_list_scope, compiled.CompiledObject):
# Here is the position stuff happening (sorting of variables).

34
jedi/parser/__init__.py
View File

@@ -60,7 +60,8 @@ class Parser(object):
self.used_names = {}
self.scope_names_stack = [{}]
logger = logging.getLogger("Jedi-Parser")
d = Driver(pytree.python_grammar, convert=self.convert, logger=logger)
d = Driver(pytree.python_grammar, self.convert,
self.error_recovery, logger=logger)
self.module = d.parse_string(source).get_parent_until()
self.module.used_names = self.used_names
@@ -96,6 +97,37 @@ class Parser(object):
new_node.names_dict = scope_names
return new_node
def error_recovery(self, grammar, stack, type, value):
"""
This parser is written in a dynamic way, meaning that this parser
allows using different grammars (even non-Python). However, error
recovery is purely written for Python.
"""
if value == '\n': # Statement is not finished.
# Now remove the whole statement.
for i, (dfa, state, node) in reversed(list(enumerate(stack))):
symbol, _, _, _ = node
# `suite` can sometimes be only simple_stmt, not stmt.
if symbol in (grammar.symbol2number['simple_stmt'],
grammar.symbol2number['stmt']):
index = i
stack[index:] = []
else:
# For now just discard everything that is not a suite or
# file_input, if we detect an error.
for i, (dfa, state, node) in reversed(list(enumerate(stack))):
symbol, _, _, _ = node
# `suite` can sometimes be only simple_stmt, not stmt.
if symbol in (grammar.symbol2number['file_input'],
grammar.symbol2number['suite']):
index = i
break
stack[index + 1:] = []
# No success finding a transition
#raise ParseError("bad input", type, value, context)
def __init__old__(self, source, module_path=None, no_docstr=False,
tokenizer=None, top_module=None):
self.no_docstr = no_docstr

5
jedi/parser/pgen2/__init__.py
View File

@@ -21,17 +21,18 @@ from . import tokenize
class Driver(object):
def __init__(self, grammar, convert=None, logger=None):
def __init__(self, grammar, convert, error_recovery, logger=None):
self.grammar = grammar
if logger is None:
logger = logging.getLogger()
self.logger = logger
self.convert = convert
self.error_recovery = error_recovery
def parse_tokens(self, tokens):
"""Parse a series of tokens and return the syntax tree."""
# XXX Move the prefix computation into a wrapper around tokenize.
p = parse.Parser(self.grammar, self.convert)
p = parse.Parser(self.grammar, self.convert, self.error_recovery)
lineno = 1
column = 0
type = value = start = end = line_text = None

36
jedi/parser/pgen2/parse.py
View File

@@ -56,7 +56,7 @@ class Parser(object):
"""
def __init__(self, grammar, convert=None):
def __init__(self, grammar, convert, error_recovery):
"""Constructor.
The grammar argument is a grammar.Grammar instance; see the
@@ -97,6 +97,7 @@ class Parser(object):
stackentry = (self.grammar.dfas[start], 0, newnode)
self.stack = [stackentry]
self.rootnode = None
self.error_recovery = error_recovery
def addtoken(self, type, value, context):
"""Add a token; return True iff this is the end of the program."""
@@ -143,7 +144,7 @@ class Parser(object):
raise ParseError("too much input",
type, value, context)
else:
self.error_recovery(type, value, context)
self.error_recovery(self.grammar, self.stack, type, value)
break
def classify(self, type, value, context):
@@ -184,34 +185,3 @@ class Parser(object):
node[-1].append(newnode)
else:
self.rootnode = newnode
def error_recovery(self, type, value, context):
"""
This parser is written in a dynamic way, meaning that this parser
allows using different grammars (even non-Python). However, error
recovery is purely written for Python.
"""
if value == '\n': # Statement is not finished.
# Now remove the whole statement.
for i, (dfa, state, node) in reversed(list(enumerate(self.stack))):
symbol, _, _, _ = node
# `suite` can sometimes be only simple_stmt, not stmt.
if symbol in (self.grammar.symbol2number['simple_stmt'],
self.grammar.symbol2number['stmt']):
index = i
self.stack[index:] = []
else:
# For now just discard everything that is not a suite or
# file_input, if we detect an error.
for i, (dfa, state, node) in reversed(list(enumerate(self.stack))):
symbol, _, _, _ = node
# `suite` can sometimes be only simple_stmt, not stmt.
if symbol in (self.grammar.symbol2number['file_input'],
self.grammar.symbol2number['suite']):
index = i
break
self.stack[index + 1:] = []
# No success finding a transition
#raise ParseError("bad input", type, value, context)