eric: comparison eric7/DebugClients/Python/coverage/parser.py

-:d856023fbeb0
+:fcca2fa618bf
 import tokenize
 from coverage import env
 from coverage.bytecode import code_objects
 from coverage.debug import short_stack
-from coverage.exceptions import NoSource, NotPython, StopEverything
+from coverage.exceptions import NoSource, NotPython, _StopEverything
 from coverage.misc import contract, join_regex, new_contract, nice_pair, one_of
 from coverage.phystokens import compile_unicode, generate_tokens, neuter_encoding_declaration
 class PythonParser:
 # number table in the bytecode.
 self.raw_statements = set()
 # The raw line numbers of excluded lines of code, as marked by pragmas.
 self.raw_excluded = set()
-# The line numbers of class and function definitions.
-self.raw_classdefs = set()
 # The line numbers of docstring lines.
 self.raw_docstrings = set()
 # Internal detail, used by lab/parser.py.
 excluding_decorators = False
 prev_toktype = token.INDENT
 first_line = None
 empty = True
 first_on_line = True
+nesting = 0
 tokgen = generate_tokens(self.text)
 for toktype, ttext, (slineno, _), (elineno, _), ltext in tokgen:
 if self.show_tokens:                # pragma: debugging
 print("%10s %5s %-20r %r" % (
 ))
 if toktype == token.INDENT:
 indent += 1
 elif toktype == token.DEDENT:
 indent -= 1
-elif toktype == token.NAME:
-if ttext == 'class':
-# Class definitions look like branches in the bytecode, so
-# we need to exclude them.  The simplest way is to note the
-# lines with the 'class' keyword.
-self.raw_classdefs.add(slineno)
 elif toktype == token.OP:
-if ttext == ':':
+if ttext == ':' and nesting == 0:
 should_exclude = (elineno in self.raw_excluded) or excluding_decorators
 if not excluding and should_exclude:
 # Start excluding a suite.  We trigger off of the colon
 # token so that the #pragma comment will be recognized on
 # the same line as the colon.
 # A decorator.
 if elineno in self.raw_excluded:
 excluding_decorators = True
 if excluding_decorators:
 self.raw_excluded.add(elineno)
+elif ttext in "([{":
+nesting += 1
+elif ttext in ")]}":
+nesting -= 1
 elif toktype == token.STRING and prev_toktype == token.INDENT:
 # Strings that are first on an indented line are docstrings.
 # (a trick from trace.py in the stdlib.) This works for
 # 99.9999% of cases.  For the rest (!) see:
 # http://stackoverflow.com/questions/1769332/x/1769794#1769794
 if l2 in self.excluded:
 # Arcs to excluded lines shouldn't count.
 continue
 exit_counts[l1] += 1
-# Class definitions have one extra exit, so remove one for each:
-for l in self.raw_classdefs:
-# Ensure key is there: class definitions can include excluded lines.
-if l in exit_counts:
-exit_counts[l] -= 1
 return exit_counts
 def missing_arc_description(self, start, end, executed_arcs=None):
 """Provide an English sentence describing a missing arc."""
 if self._missing_arc_fragments is None:
 # Alternative Python implementations don't always provide all the
 # attributes on code objects that we need to do the analysis.
 for attr in ['co_lnotab', 'co_firstlineno']:
 if not hasattr(self.code, attr):
-raise StopEverything(                   # pragma: only jython
+raise _StopEverything(                  # pragma: only jython
 "This implementation of Python doesn't support code analysis.\n" +
 "Run coverage.py under another Python for this command."
 )
 def child_parsers(self):

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/parser.py

eric7/DebugClients/Python/coverage/parser.py