""" Basically a parser that is faster, because it tries to parse only parts and if anything changes, it only reparses the changed parts. But because it's not finished (and still not working as I want), I won't document it any further. """ import re from itertools import chain from jedi._compatibility import use_metaclass from jedi import settings from jedi.parser import Parser from jedi.parser import tree from jedi import cache from jedi import debug from jedi.parser.tokenize import (source_tokens, NEWLINE, ENDMARKER, INDENT, DEDENT) FLOWS = 'if', 'else', 'elif', 'while', 'with', 'try', 'except', 'finally', 'for' class FastModule(tree.Module): type = 'file_input' def __init__(self, module_path): super(FastModule, self).__init__([]) self.modules = [] self.reset_caches() self.names_dict = {} self.path = module_path def reset_caches(self): self.modules = [] try: del self._used_names # Remove the used names cache. except AttributeError: pass # It was never used. @property @cache.underscore_memoization def used_names(self): return MergedNamesDict([m.used_names for m in self.modules]) @property def global_names(self): return [name for m in self.modules for name in m.global_names] @property def error_statement_stacks(self): return [e for m in self.modules for e in m.error_statement_stacks] def __repr__(self): return "" % (type(self).__name__, self.name, self.start_pos[0], self.end_pos[0]) # To avoid issues with with the `parser.Parser`, we need setters that do # nothing, because if pickle comes along and sets those values. @global_names.setter def global_names(self, value): pass @error_statement_stacks.setter def error_statement_stacks(self, value): pass @used_names.setter def used_names(self, value): pass class MergedNamesDict(object): def __init__(self, dicts): self.dicts = dicts def __iter__(self): return iter(set(key for dct in self.dicts for key in dct)) def __getitem__(self, value): return list(chain.from_iterable(dct.get(value, []) for dct in self.dicts)) def items(self): dct = {} for d in self.dicts: for key, values in d.items(): try: dct_values = dct[key] dct_values += values except KeyError: dct[key] = list(values) return dct.items() def values(self): lst = [] for dct in self.dicts: lst += dct.values() return lst class CachedFastParser(type): """ This is a metaclass for caching `FastParser`. """ def __call__(self, grammar, source, module_path=None): if not settings.fast_parser: return Parser(grammar, source, module_path) pi = cache.parser_cache.get(module_path, None) if pi is None or isinstance(pi.parser, Parser): p = super(CachedFastParser, self).__call__(grammar, source, module_path) else: p = pi.parser # pi is a `cache.ParserCacheItem` p.update(source) return p class ParserNode(object): def __init__(self, fast_module, parser, source): self._fast_module = fast_module self.parent = None self._node_children = [] self.source = source self.hash = hash(source) self.parser = parser try: # With fast_parser we have either 1 subscope or only statements. self._content_scope = parser.module.subscopes[0] except IndexError: self._content_scope = parser.module else: self._rewrite_last_newline() # We need to be able to reset the original children of a parser. self._old_children = list(self._content_scope.children) def _rewrite_last_newline(self): """ The ENDMARKER can contain a newline in the prefix. However this prefix really belongs to the function - respectively to the next function or parser node. If we don't rewrite that newline, we end up with a newline in the wrong position, i.d. at the end of the file instead of in the middle. """ c = self._content_scope.children if tree.is_node(c[-1], 'suite'): # In a simple_stmt there's no DEDENT. end_marker = self.parser.module.children[-1] # Set the DEDENT prefix instead of the ENDMARKER. c[-1].children[-1].prefix = end_marker.prefix end_marker.prefix = '' def __repr__(self): module = self.parser.module try: return '<%s: %s-%s>' % (type(self).__name__, module.start_pos, module.end_pos) except IndexError: # There's no module yet. return '<%s: empty>' % type(self).__name__ def reset_node(self): """ Removes changes that were applied in this class. """ self._node_children = [] scope = self._content_scope scope.children = list(self._old_children) try: # This works if it's a MergedNamesDict. # We are correcting it, because the MergedNamesDicts are artificial # and can change after closing a node. scope.names_dict = scope.names_dict.dicts[0] except AttributeError: pass def close(self): """ Closes the current parser node. This means that after this no further nodes should be added anymore. """ # We only need to replace the dict if multiple dictionaries are used: if self._node_children: dcts = [n.parser.module.names_dict for n in self._node_children] # Need to insert the own node as well. dcts.insert(0, self._content_scope.names_dict) self._content_scope.names_dict = MergedNamesDict(dcts) def parent_until_indent(self, indent=None): if (indent is None or self._indent >= indent) and self.parent is not None: self.close() return self.parent.parent_until_indent(indent) return self @property def _indent(self): if not self.parent: return 0 return self.parser.module.children[0].start_pos[1] def add_node(self, node, line_offset): """Adding a node means adding a node that was already added earlier""" # Changing the line offsets is very important, because if they don't # fit, all the start_pos values will be wrong. m = node.parser.module node.parser.position_modifier.line = line_offset self._fast_module.modules.append(m) node.parent = self self._node_children.append(node) # Insert parser objects into current structure. We only need to set the # parents and children in a good way. scope = self._content_scope for child in m.children: child.parent = scope scope.children.append(child) return node def all_sub_nodes(self): """ Returns all nodes including nested ones. """ for n in self._node_children: yield n for y in n.all_sub_nodes(): yield y @cache.underscore_memoization # Should only happen once! def remove_last_newline(self): self.parser.remove_last_newline() class FastParser(use_metaclass(CachedFastParser)): _FLOWS_NEED_SPACE = 'if', 'elif', 'while', 'with', 'except', 'for' _FLOWS_NEED_COLON = 'else', 'try', 'except', 'finally' _keyword_re = re.compile('^[ \t]*(def |class |@|(?:%s)|(?:%s)\s*:)' % ('|'.join(_FLOWS_NEED_SPACE), '|'.join(_FLOWS_NEED_COLON))) def __init__(self, grammar, source, module_path=None): # set values like `tree.Module`. self._grammar = grammar self.module_path = module_path self._reset_caches() self.update(source) def _reset_caches(self): self.module = FastModule(self.module_path) self.current_node = ParserNode(self.module, self, '') def update(self, source): # For testing purposes: It is important that the number of parsers used # can be minimized. With these variables we can test against that. self.number_parsers_used = 0 self.number_of_splits = 0 self.number_of_misses = 0 self.module.reset_caches() try: self._parse(source) except: # FastParser is cached, be careful with exceptions. self._reset_caches() raise def _split_parts(self, source): """ Split the source code into different parts. This makes it possible to parse each part seperately and therefore cache parts of the file and not everything. """ def gen_part(): text = ''.join(current_lines) del current_lines[:] self.number_of_splits += 1 return text def just_newlines(current_lines): for line in current_lines: line = line.lstrip('\t \n\r') if line and line[0] != '#': return False return True # Split only new lines. Distinction between \r\n is the tokenizer's # job. # It seems like there's no problem with form feed characters here, # because we're not counting lines. self._lines = source.splitlines(True) current_lines = [] is_decorator = False # Use -1, because that indent is always smaller than any other. indent_list = [-1, 0] new_indent = False parentheses_level = 0 flow_indent = None previous_line = None # All things within flows are simply being ignored. for i, l in enumerate(self._lines): # Handle backslash newline escaping. if l.endswith('\\\n') or l.endswith('\\\r\n'): if previous_line is not None: previous_line += l else: previous_line = l continue if previous_line is not None: l = previous_line + l previous_line = None # check for dedents s = l.lstrip('\t \n\r') indent = len(l) - len(s) if not s or s[0] == '#': current_lines.append(l) # Just ignore comments and blank lines continue if new_indent: if indent > indent_list[-2]: # Set the actual indent, not just the random old indent + 1. indent_list[-1] = indent new_indent = False while indent <= indent_list[-2]: # -> dedent indent_list.pop() # This automatically resets the flow_indent if there was a # dedent or a flow just on one line (with one simple_stmt). new_indent = False if flow_indent is None and current_lines and not parentheses_level: yield gen_part() flow_indent = None # Check lines for functions/classes and split the code there. if flow_indent is None: m = self._keyword_re.match(l) if m: # Strip whitespace and colon from flows as a check. if m.group(1).strip(' \t\r\n:') in FLOWS: if not parentheses_level: flow_indent = indent else: if not is_decorator and not just_newlines(current_lines): yield gen_part() is_decorator = '@' == m.group(1) if not is_decorator: parentheses_level = 0 # The new indent needs to be higher indent_list.append(indent + 1) new_indent = True elif is_decorator: is_decorator = False parentheses_level = \ max(0, (l.count('(') + l.count('[') + l.count('{') - l.count(')') - l.count(']') - l.count('}'))) current_lines.append(l) if current_lines: yield gen_part() def _parse(self, source): """ :type source: str """ added_newline = False if not source or source[-1] != '\n': # To be compatible with Pythons grammar, we need a newline at the # end. The parser would handle it, but since the fast parser abuses # the normal parser in various ways, we need to care for this # ourselves. source += '\n' added_newline = True next_line_offset = line_offset = 0 start = 0 nodes = list(self.current_node.all_sub_nodes()) # Now we can reset the node, because we have all the old nodes. self.current_node.reset_node() last_end_line = 1 for code_part in self._split_parts(source): next_line_offset += code_part.count('\n') # If the last code part parsed isn't equal to the current end_pos, # we know that the parser went further (`def` start in a # docstring). So just parse the next part. if line_offset + 1 == last_end_line: self.current_node = self._get_node(code_part, source[start:], line_offset, nodes) else: # Means that some lines where not fully parsed. Parse it now. # This is a very rare case. Should only happens with very # strange code bits. self.number_of_misses += 1 while last_end_line < next_line_offset + 1: line_offset = last_end_line - 1 # We could calculate the src in a more complicated way to # make caching here possible as well. However, this is # complicated and error-prone. Since this is not very often # called - just ignore it. src = ''.join(self._lines[line_offset:]) self.current_node = self._get_node(code_part, src, line_offset, nodes) last_end_line = self.current_node.parser.module.end_pos[0] debug.dbg('While parsing %s, line %s slowed down the fast parser.', self.module_path, line_offset + 1) line_offset = next_line_offset start += len(code_part) last_end_line = self.current_node.parser.module.end_pos[0] if added_newline: self.current_node.remove_last_newline() # Now that the for loop is finished, we still want to close all nodes. self.current_node = self.current_node.parent_until_indent() self.current_node.close() debug.dbg('Parsed %s, with %s parsers in %s splits.' % (self.module_path, self.number_parsers_used, self.number_of_splits)) def _get_node(self, source, parser_code, line_offset, nodes): """ Side effect: Alters the list of nodes. """ indent = len(source) - len(source.lstrip('\t ')) self.current_node = self.current_node.parent_until_indent(indent) h = hash(source) for index, node in enumerate(nodes): if node.hash == h and node.source == source: node.reset_node() nodes.remove(node) break else: tokenizer = FastTokenizer(parser_code) self.number_parsers_used += 1 p = Parser(self._grammar, parser_code, self.module_path, tokenizer=tokenizer) end = line_offset + p.module.end_pos[0] used_lines = self._lines[line_offset:end - 1] code_part_actually_used = ''.join(used_lines) node = ParserNode(self.module, p, code_part_actually_used) self.current_node.add_node(node, line_offset) return node class FastTokenizer(object): """ Breaks when certain conditions are met, i.e. a new function or class opens. """ def __init__(self, source): self.source = source self._gen = source_tokens(source) self._closed = False # fast parser options self.current = self.previous = NEWLINE, '', (0, 0) self._in_flow = False self._is_decorator = False self._first_stmt = True self._parentheses_level = 0 self._indent_counter = 0 self._flow_indent_counter = 0 self._returned_endmarker = False self._expect_indent = False def __iter__(self): return self def next(self): """ Python 2 Compatibility """ return self.__next__() def __next__(self): if self._closed: return self._finish_dedents() typ, value, start_pos, prefix = current = next(self._gen) if typ == ENDMARKER: self._closed = True self._returned_endmarker = True return current self.previous = self.current self.current = current if typ == INDENT: self._indent_counter += 1 if not self._expect_indent and not self._first_stmt and not self._in_flow: # This does not mean that there is an actual flow, it means # that the INDENT is syntactically wrong. self._flow_indent_counter = self._indent_counter - 1 self._in_flow = True self._expect_indent = False elif typ == DEDENT: self._indent_counter -= 1 if self._in_flow: if self._indent_counter == self._flow_indent_counter: self._in_flow = False else: self._closed = True return current if value in ('def', 'class') and self._parentheses_level \ and re.search(r'\n[ \t]*\Z', prefix): # Account for the fact that an open parentheses before a function # will reset the parentheses counter, but new lines before will # still be ignored. So check the prefix. # TODO what about flow parentheses counter resets in the tokenizer? self._parentheses_level = 0 return self._close() # Parentheses ignore the indentation rules. The other three stand for # new lines. if self.previous[0] in (NEWLINE, INDENT, DEDENT) \ and not self._parentheses_level and typ not in (INDENT, DEDENT): if not self._in_flow: if value in FLOWS: self._flow_indent_counter = self._indent_counter self._first_stmt = False elif value in ('def', 'class', '@'): # The values here are exactly the same check as in # _split_parts, but this time with tokenize and therefore # precise. if not self._first_stmt and not self._is_decorator: return self._close() self._is_decorator = '@' == value if not self._is_decorator: self._first_stmt = False self._expect_indent = True elif self._expect_indent: return self._close() else: self._first_stmt = False if value in '([{' and value: self._parentheses_level += 1 elif value in ')]}' and value: # Ignore closing parentheses, because they are all # irrelevant for the indentation. self._parentheses_level = max(self._parentheses_level - 1, 0) return current def _close(self): if self._first_stmt: # Continue like nothing has happened, because we want to enter # the first class/function. if self.current[1] != '@': self._first_stmt = False return self.current else: self._closed = True return self._finish_dedents() def _finish_dedents(self): if self._indent_counter: self._indent_counter -= 1 return DEDENT, '', self.current[2], '' elif not self._returned_endmarker: self._returned_endmarker = True return ENDMARKER, '', self.current[2], self._get_prefix() else: raise StopIteration def _get_prefix(self): """ We're using the current prefix for the endmarker to not loose any information. However we care about "lost" lines. The prefix of the current line (indent) will always be included in the current line. """ cur = self.current while cur[0] == DEDENT: cur = next(self._gen) prefix = cur[3] # \Z for the end of the string. $ is bugged, because it has the # same behavior with or without re.MULTILINE. return re.sub(r'[^\n]+\Z', '', prefix)