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

-:d728227e8ebb
+:0802ae193343
 import re
 import token
 import tokenize
 from coverage import env
-from coverage.backward import range    # pylint: disable=redefined-builtin
-from coverage.backward import bytes_to_ints, string_class
 from coverage.bytecode import code_objects
 from coverage.debug import short_stack
+from coverage.exceptions import NoSource, NotPython, StopEverything
 from coverage.misc import contract, join_regex, new_contract, nice_pair, one_of
-from coverage.misc import NoSource, NotPython, StopEverything
 from coverage.phystokens import compile_unicode, generate_tokens, neuter_encoding_declaration
-class PythonParser(object):
+class PythonParser:
 """Parse code to find executable lines, excluded lines, etc.
 This information is all based on static analysis: no code execution is
 involved.
 self.text = text
 if not self.text:
 from coverage.python import get_python_source
 try:
 self.text = get_python_source(self.filename)
-except IOError as err:
+except OSError as err:
-raise NoSource(
+raise NoSource(f"No source for code: '{self.filename}': {err}") from err
-"No source for code: '%s': %s" % (self.filename, err)
-)
 self.exclude = exclude
 # The text lines of the parsed code.
 self.lines = self.text.split('\n')
 # A dict mapping line numbers to lexical statement starts for
 # multi-line statements.
 self._multiline = {}
-# Lazily-created ByteParser, arc data, and missing arc descriptions.
+# Lazily-created arc data, and missing arc descriptions.
-self._byte_parser = None
 self._all_arcs = None
 self._missing_arc_fragments = None
-@property
-def byte_parser(self):
-"""Create a ByteParser on demand."""
-if not self._byte_parser:
-self._byte_parser = ByteParser(self.text, filename=self.filename)
-return self._byte_parser
 def lines_matching(self, *regexes):
 """Find the lines matching one of a list of regexes.
 Returns a set of line numbers, the lines that contain a match for one
 of the regexes in `regexes`.  The entire line needn't match, just a
 part of it.
 """
 combined = join_regex(regexes)
-if env.PY2:
-combined = combined.decode("utf8")
 regex_c = re.compile(combined)
 matches = set()
 for i, ltext in enumerate(self.lines, start=1):
 if regex_c.search(ltext):
 matches.add(i)
 prev_toktype = toktype
 # Find the starts of the executable statements.
 if not empty:
-self.raw_statements.update(self.byte_parser._find_statements())
+byte_parser = ByteParser(self.text, filename=self.filename)
+self.raw_statements.update(byte_parser._find_statements())
 # The first line of modules can lie and say 1 always, even if the first
 # line of code is later. If so, map 1 to the actual first line of the
 # module.
 if env.PYBEHAVIOR.module_firstline_1 and self._multiline:
 if hasattr(err, "lineno"):
 lineno = err.lineno         # IndentationError
 else:
 lineno = err.args[1][0]     # TokenError
 raise NotPython(
-u"Couldn't parse '%s' as Python source: '%s' at line %d" % (
+f"Couldn't parse '{self.filename}' as Python source: " +
-self.filename, err.args[0], lineno
+f"{err.args[0]!r} at line {lineno}"
-)
+) from err
-)
 self.excluded = self.first_lines(self.raw_excluded)
 ignore = self.excluded | self.raw_docstrings
 starts = self.raw_statements - ignore
 emsg = "didn't jump to the function exit"
 else:
 emsg = "didn't jump to line {lineno}"
 emsg = emsg.format(lineno=end)
-msg = "line {start} {emsg}".format(start=actual_start, emsg=emsg)
+msg = f"line {actual_start} {emsg}"
 if smsg is not None:
-msg += ", because {smsg}".format(smsg=smsg.format(lineno=actual_start))
+msg += f", because {smsg.format(lineno=actual_start)}"
 msgs.append(msg)
 return " or ".join(msgs)
-class ByteParser(object):
+class ByteParser:
 """Parse bytecode to understand the structure of code."""
 @contract(text='unicode')
 def __init__(self, text, code=None, filename=None):
 self.text = text
 else:
 try:
 self.code = compile_unicode(text, filename, "exec")
 except SyntaxError as synerr:
 raise NotPython(
-u"Couldn't parse '%s' as Python source: '%s' at line %d" % (
+"Couldn't parse '%s' as Python source: '%s' at line %d" % (
 filename, synerr.msg, synerr.lineno
 )
-)
+) from synerr
 # 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
-"This implementation of Python doesn't support code analysis.\n"
+"This implementation of Python doesn't support code analysis.\n" +
 "Run coverage.py under another Python for this command."
 )
 def child_parsers(self):
 """Iterate over all the code objects nested within this one.
 for _, _, line in self.code.co_lines():
 if line is not None:
 yield line
 else:
 # Adapted from dis.py in the standard library.
-byte_increments = bytes_to_ints(self.code.co_lnotab[0::2])
+byte_increments = self.code.co_lnotab[0::2]
-line_increments = bytes_to_ints(self.code.co_lnotab[1::2])
+line_increments = self.code.co_lnotab[1::2]
 last_line_num = None
 line_num = self.code.co_firstlineno
 byte_num = 0
 for byte_incr, line_incr in zip(byte_increments, line_increments):
 into all code objects reachable from `self.code`.
 """
 for bp in self.child_parsers():
 # Get all of the lineno information from this code.
-for l in bp._line_numbers():
+yield from bp._line_numbers()
-yield l
 #
 # AST analysis
 #
-class LoopBlock(object):
+class BlockBase:
+"""
+Blocks need to handle various exiting statements in their own ways.
+All of these methods take a list of exits, and a callable `add_arc`
+function that they can use to add arcs if needed.  They return True if the
+exits are handled, or False if the search should continue up the block
+stack.
+"""
+# pylint: disable=unused-argument
+def process_break_exits(self, exits, add_arc):
+"""Process break exits."""
+# Because break can only appear in loops, and most subclasses
+# implement process_break_exits, this function is never reached.
+raise AssertionError
+def process_continue_exits(self, exits, add_arc):
+"""Process continue exits."""
+# Because continue can only appear in loops, and most subclasses
+# implement process_continue_exits, this function is never reached.
+raise AssertionError
+def process_raise_exits(self, exits, add_arc):
+"""Process raise exits."""
+return False
+def process_return_exits(self, exits, add_arc):
+"""Process return exits."""
+return False
+class LoopBlock(BlockBase):
 """A block on the block stack representing a `for` or `while` loop."""
 @contract(start=int)
 def __init__(self, start):
 # The line number where the loop starts.
 self.start = start
 # A set of ArcStarts, the arcs from break statements exiting this loop.
 self.break_exits = set()
+def process_break_exits(self, exits, add_arc):
-class FunctionBlock(object):
+self.break_exits.update(exits)
+return True
+def process_continue_exits(self, exits, add_arc):
+for xit in exits:
+add_arc(xit.lineno, self.start, xit.cause)
+return True
+class FunctionBlock(BlockBase):
 """A block on the block stack representing a function definition."""
 @contract(start=int, name=str)
 def __init__(self, start, name):
 # The line number where the function starts.
 self.start = start
 # The name of the function.
 self.name = name
+def process_raise_exits(self, exits, add_arc):
-class TryBlock(object):
+for xit in exits:
+add_arc(
+xit.lineno, -self.start, xit.cause,
+f"didn't except from function {self.name!r}",
+)
+return True
+def process_return_exits(self, exits, add_arc):
+for xit in exits:
+add_arc(
+xit.lineno, -self.start, xit.cause,
+f"didn't return from function {self.name!r}",
+)
+return True
+class TryBlock(BlockBase):
 """A block on the block stack representing a `try` block."""
 @contract(handler_start='int|None', final_start='int|None')
 def __init__(self, handler_start, final_start):
 # The line number of the first "except" handler, if any.
 self.handler_start = handler_start
 # The ArcStarts for breaks/continues/returns/raises inside the "try:"
 # that need to route through the "finally:" clause.
 self.break_from = set()
 self.continue_from = set()
+self.raise_from = set()
 self.return_from = set()
-self.raise_from = set()
+def process_break_exits(self, exits, add_arc):
+if self.final_start is not None:
+self.break_from.update(exits)
+return True
+return False
+def process_continue_exits(self, exits, add_arc):
+if self.final_start is not None:
+self.continue_from.update(exits)
+return True
+return False
+def process_raise_exits(self, exits, add_arc):
+if self.handler_start is not None:
+for xit in exits:
+add_arc(xit.lineno, self.handler_start, xit.cause)
+else:
+assert self.final_start is not None
+self.raise_from.update(exits)
+return True
+def process_return_exits(self, exits, add_arc):
+if self.final_start is not None:
+self.return_from.update(exits)
+return True
+return False
+class WithBlock(BlockBase):
+"""A block on the block stack representing a `with` block."""
+@contract(start=int)
+def __init__(self, start):
+# We only ever use this block if it is needed, so that we don't have to
+# check this setting in all the methods.
+assert env.PYBEHAVIOR.exit_through_with
+# The line number of the with statement.
+self.start = start
+# The ArcStarts for breaks/continues/returns/raises inside the "with:"
+# that need to go through the with-statement while exiting.
+self.break_from = set()
+self.continue_from = set()
+self.return_from = set()
+def _process_exits(self, exits, add_arc, from_set=None):
+"""Helper to process the four kinds of exits."""
+for xit in exits:
+add_arc(xit.lineno, self.start, xit.cause)
+if from_set is not None:
+from_set.update(exits)
+return True
+def process_break_exits(self, exits, add_arc):
+return self._process_exits(exits, add_arc, self.break_from)
+def process_continue_exits(self, exits, add_arc):
+return self._process_exits(exits, add_arc, self.continue_from)
+def process_raise_exits(self, exits, add_arc):
+return self._process_exits(exits, add_arc)
+def process_return_exits(self, exits, add_arc):
+return self._process_exits(exits, add_arc, self.return_from)
 class ArcStart(collections.namedtuple("Arc", "lineno, cause")):
 """The information needed to start an arc.
 "Line 17 didn't run because {cause}."  The fragment can include "{lineno}"
 to have `lineno` interpolated into it.
 """
 def __new__(cls, lineno, cause=None):
-return super(ArcStart, cls).__new__(cls, lineno, cause)
+return super().__new__(cls, lineno, cause)
 # Define contract words that PyContract doesn't have.
 # ArcStarts is for a list or set of ArcStart's.
 new_contract('ArcStarts', lambda seq: all(isinstance(x, ArcStart) for x in seq))
-# Turn on AST dumps with an environment variable.
+class NodeList:
-# $set_env.py: COVERAGE_AST_DUMP - Dump the AST nodes when parsing code.
-AST_DUMP = bool(int(os.environ.get("COVERAGE_AST_DUMP", 0)))
-class NodeList(object):
 """A synthetic fictitious node, containing a sequence of nodes.
 This is used when collapsing optimized if-statements, to represent the
 unconditional execution of one of the clauses.
 """
 def __init__(self, body):
 self.body = body
 self.lineno = body[0].lineno
 # TODO: some add_arcs methods here don't add arcs, they return them. Rename them.
 # TODO: the cause messages have too many commas.
 # TODO: Shouldn't the cause messages join with "and" instead of "or"?
-class AstArcAnalyzer(object):
+def ast_parse(text):
+"""How we create an AST parse."""
+return ast.parse(neuter_encoding_declaration(text))
+class AstArcAnalyzer:
 """Analyze source text with an AST to find executable code paths."""
 @contract(text='unicode', statements=set)
 def __init__(self, text, statements, multiline):
-self.root_node = ast.parse(neuter_encoding_declaration(text))
+self.root_node = ast_parse(text)
 # TODO: I think this is happening in too many places.
 self.statements = {multiline.get(l, l) for l in statements}
 self.multiline = multiline
-if AST_DUMP:                                # pragma: debugging
+# Turn on AST dumps with an environment variable.
+# $set_env.py: COVERAGE_AST_DUMP - Dump the AST nodes when parsing code.
+dump_ast = bool(int(os.environ.get("COVERAGE_AST_DUMP", 0)))
+if dump_ast:                                # pragma: debugging
 # Dump the AST so that failing tests have helpful output.
-print("Statements: {}".format(self.statements))
+print(f"Statements: {self.statements}")
-print("Multiline map: {}".format(self.multiline))
+print(f"Multiline map: {self.multiline}")
 ast_dump(self.root_node)
 self.arcs = set()
 # A map from arc pairs to a list of pairs of sentence fragments:
 @contract(start=int, end=int)
 def add_arc(self, start, end, smsg=None, emsg=None):
 """Add an arc, including message fragments to use if it is missing."""
 if self.debug:                      # pragma: debugging
-print("\nAdding arc: ({}, {}): {!r}, {!r}".format(start, end, smsg, emsg))
+print(f"\nAdding arc: ({start}, {end}): {smsg!r}, {emsg!r}")
 print(short_stack(limit=6))
 self.arcs.add((start, end))
 if smsg is not None or emsg is not None:
 self.missing_arc_fragments[(start, end)].append((smsg, emsg))
 return self.line_for_node(node.value)
 _line__ClassDef = _line_decorated
 def _line__Dict(self, node):
-# Python 3.5 changed how dict literals are made.
+if node.keys:
-if env.PYVERSION >= (3, 5) and node.keys:
 if node.keys[0] is not None:
 return node.keys[0].lineno
 else:
 # Unpacked dict literals `{**{'a':1}}` have None as the key,
 # use the value in that case.
 # Empty modules have no line number, they always start at 1.
 return 1
 # The node types that just flow to the next node with no complications.
 OK_TO_DEFAULT = {
-"Assign", "Assert", "AugAssign", "Delete", "Exec", "Expr", "Global",
+"AnnAssign", "Assign", "Assert", "AugAssign", "Delete", "Expr", "Global",
-"Import", "ImportFrom", "Nonlocal", "Pass", "Print",
+"Import", "ImportFrom", "Nonlocal", "Pass",
 }
 @contract(returns='ArcStarts')
 def add_arcs(self, node):
 """Add the arcs for `node`.
 handler = getattr(self, "_handle__" + node_name, None)
 if handler is not None:
 return handler(node)
 else:
 # No handler: either it's something that's ok to default (a simple
-# statement), or it's something we overlooked. Change this 0 to 1
+# statement), or it's something we overlooked.
-# to see if it's overlooked.
+if env.TESTING:
-if 0:
 if node_name not in self.OK_TO_DEFAULT:
-print("*** Unhandled: {}".format(node))
+raise Exception(f"*** Unhandled: {node}")       # pragma: only failure
 # Default for simple statements: one exit from this node.
 return {ArcStart(self.line_for_node(node))}
 @one_of("from_start, prev_starts")
 # is nearer.
 @contract(exits='ArcStarts')
 def process_break_exits(self, exits):
 """Add arcs due to jumps from `exits` being breaks."""
-for block in self.nearest_blocks():
+for block in self.nearest_blocks():                         # pragma: always breaks
-if isinstance(block, LoopBlock):
+if block.process_break_exits(exits, self.add_arc):
-block.break_exits.update(exits)
-break
-elif isinstance(block, TryBlock) and block.final_start is not None:
-block.break_from.update(exits)
 break
 @contract(exits='ArcStarts')
 def process_continue_exits(self, exits):
 """Add arcs due to jumps from `exits` being continues."""
-for block in self.nearest_blocks():
+for block in self.nearest_blocks():                         # pragma: always breaks
-if isinstance(block, LoopBlock):
+if block.process_continue_exits(exits, self.add_arc):
-for xit in exits:
-self.add_arc(xit.lineno, block.start, xit.cause)
-break
-elif isinstance(block, TryBlock) and block.final_start is not None:
-block.continue_from.update(exits)
 break
 @contract(exits='ArcStarts')
 def process_raise_exits(self, exits):
 """Add arcs due to jumps from `exits` being raises."""
 for block in self.nearest_blocks():
-if isinstance(block, TryBlock):
+if block.process_raise_exits(exits, self.add_arc):
-if block.handler_start is not None:
-for xit in exits:
-self.add_arc(xit.lineno, block.handler_start, xit.cause)
-break
-elif block.final_start is not None:
-block.raise_from.update(exits)
-break
-elif isinstance(block, FunctionBlock):
-for xit in exits:
-self.add_arc(
-xit.lineno, -block.start, xit.cause,
-"didn't except from function {!r}".format(block.name),
-)
 break
 @contract(exits='ArcStarts')
 def process_return_exits(self, exits):
 """Add arcs due to jumps from `exits` being returns."""
-for block in self.nearest_blocks():
+for block in self.nearest_blocks():                         # pragma: always breaks
-if isinstance(block, TryBlock) and block.final_start is not None:
+if block.process_return_exits(exits, self.add_arc):
-block.return_from.update(exits)
 break
-elif isinstance(block, FunctionBlock):
-for xit in exits:
-self.add_arc(
-xit.lineno, -block.start, xit.cause,
-"didn't return from function {!r}".format(block.name),
-)
-break
 # Handlers: _handle__*
 #
 # Each handler deals with a specific AST node type, dispatched from
 # add_arcs.  Handlers return the set of exits from that node, and can
 # also call self.add_arc to record arcs they find.  These functions mirror
 # the Python semantics of each syntactic construct.  See the docstring
 # for add_arcs to understand the concept of exits from a node.
+#
+# Every node type that represents a statement should have a handler, or it
+# should be listed in OK_TO_DEFAULT.
 @contract(returns='ArcStarts')
 def _handle__Break(self, node):
 here = self.line_for_node(node)
 break_start = ArcStart(here, cause="the break on line {lineno} wasn't executed")
 from_start = ArcStart(start, cause="the condition on line {lineno} was never false")
 exits |= self.add_body_arcs(node.orelse, from_start=from_start)
 return exits
 @contract(returns='ArcStarts')
+def _handle__Match(self, node):
+start = self.line_for_node(node)
+last_start = start
+exits = set()
+had_wildcard = False
+for case in node.cases:
+case_start = self.line_for_node(case.pattern)
+if isinstance(case.pattern, ast.MatchAs):
+had_wildcard = True
+self.add_arc(last_start, case_start, "the pattern on line {lineno} always matched")
+from_start = ArcStart(case_start, cause="the pattern on line {lineno} never matched")
+exits |= self.add_body_arcs(case.body, from_start=from_start)
+last_start = case_start
+if not had_wildcard:
+exits.add(from_start)
+return exits
+@contract(returns='ArcStarts')
 def _handle__NodeList(self, node):
 start = self.line_for_node(node)
 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
 return exits
 if node.finalbody:
 final_start = self.line_for_node(node.finalbody[0])
 else:
 final_start = None
+# This is true by virtue of Python syntax: have to have either except
+# or finally, or both.
+assert handler_start is not None or final_start is not None
 try_block = TryBlock(handler_start, final_start)
 self.block_stack.append(try_block)
 start = self.line_for_node(node)
 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
 cause = " or ".join(causes)
 exits = {ArcStart(xit.lineno, cause) for xit in exits}
 return exits
 @contract(returns='ArcStarts')
-def _handle__TryExcept(self, node):
-# Python 2.7 uses separate TryExcept and TryFinally nodes. If we get
-# TryExcept, it means there was no finally, so fake it, and treat as
-# a general Try node.
-node.finalbody = []
-return self._handle__Try(node)
-@contract(returns='ArcStarts')
-def _handle__TryFinally(self, node):
-# Python 2.7 uses separate TryExcept and TryFinally nodes. If we get
-# TryFinally, see if there's a TryExcept nested inside. If so, merge
-# them. Otherwise, fake fields to complete a Try node.
-node.handlers = []
-node.orelse = []
-first = node.body[0]
-if first.__class__.__name__ == "TryExcept" and node.lineno == first.lineno:
-assert len(node.body) == 1
-node.body = first.body
-node.handlers = first.handlers
-node.orelse = first.orelse
-return self._handle__Try(node)
-@contract(returns='ArcStarts')
 def _handle__While(self, node):
 start = to_top = self.line_for_node(node.test)
 constant_test = self.is_constant_expr(node.test)
 top_is_body0 = False
-if constant_test and (env.PY3 or constant_test == "Num"):
+if constant_test:
 top_is_body0 = True
 if env.PYBEHAVIOR.keep_constant_test:
 top_is_body0 = False
 if top_is_body0:
 to_top = self.line_for_node(node.body[0])
 return exits
 @contract(returns='ArcStarts')
 def _handle__With(self, node):
 start = self.line_for_node(node)
+if env.PYBEHAVIOR.exit_through_with:
+self.block_stack.append(WithBlock(start=start))
 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
+if env.PYBEHAVIOR.exit_through_with:
+with_block = self.block_stack.pop()
+with_exit = {ArcStart(start)}
+if exits:
+for xit in exits:
+self.add_arc(xit.lineno, start)
+exits = with_exit
+if with_block.break_from:
+self.process_break_exits(
+self._combine_finally_starts(with_block.break_from, with_exit)
+)
+if with_block.continue_from:
+self.process_continue_exits(
+self._combine_finally_starts(with_block.continue_from, with_exit)
+)
+if with_block.return_from:
+self.process_return_exits(
+self._combine_finally_starts(with_block.return_from, with_exit)
+)
 return exits
 _handle__AsyncWith = _handle__With
+# Code object dispatchers: _code_object__*
+#
+# These methods are used by analyze() as the start of the analysis.
+# There is one for each construct with a code object.
 def _code_object__Module(self, node):
 start = self.line_for_node(node)
 if node.body:
 exits = self.add_body_arcs(node.body, from_start=ArcStart(-start))
 self.add_arc(-start, start)
 exits = self.add_body_arcs(node.body, from_start=ArcStart(start))
 for xit in exits:
 self.add_arc(
 xit.lineno, -start, xit.cause,
-"didn't exit the body of class {!r}".format(node.name),
+f"didn't exit the body of class {node.name!r}",
 )
-def _make_oneline_code_method(noun):     # pylint: disable=no-self-argument
+def _make_expression_code_method(noun):                     # pylint: disable=no-self-argument
-"""A function to make methods for online callable _code_object__ methods."""
+"""A function to make methods for expression-based callable _code_object__ methods."""
-def _code_object__oneline_callable(self, node):
+def _code_object__expression_callable(self, node):
 start = self.line_for_node(node)
-self.add_arc(-start, start, None, "didn't run the {} on line {}".format(noun, start))
+self.add_arc(-start, start, None, f"didn't run the {noun} on line {start}")
-self.add_arc(
+self.add_arc(start, -start, None, f"didn't finish the {noun} on line {start}")
-start, -start, None,
+return _code_object__expression_callable
-"didn't finish the {} on line {}".format(noun, start),
-)
+_code_object__Lambda = _make_expression_code_method("lambda")
-return _code_object__oneline_callable
+_code_object__GeneratorExp = _make_expression_code_method("generator expression")
+_code_object__DictComp = _make_expression_code_method("dictionary comprehension")
-_code_object__Lambda = _make_oneline_code_method("lambda")
+_code_object__SetComp = _make_expression_code_method("set comprehension")
-_code_object__GeneratorExp = _make_oneline_code_method("generator expression")
+_code_object__ListComp = _make_expression_code_method("list comprehension")
-_code_object__DictComp = _make_oneline_code_method("dictionary comprehension")
-_code_object__SetComp = _make_oneline_code_method("set comprehension")
-if env.PY3:
+# Code only used when dumping the AST for debugging.
-_code_object__ListComp = _make_oneline_code_method("list comprehension")
+SKIP_DUMP_FIELDS = ["ctx"]
-if AST_DUMP:            # pragma: debugging
+def _is_simple_value(value):
-# Code only used when dumping the AST for debugging.
+"""Is `value` simple enough to be displayed on a single line?"""
+return (
-SKIP_DUMP_FIELDS = ["ctx"]
+value in [None, [], (), {}, set()] or
+isinstance(value, (bytes, int, float, str))
-def _is_simple_value(value):
+)
-"""Is `value` simple enough to be displayed on a single line?"""
-return (
+def ast_dump(node, depth=0, print=print):   # pylint: disable=redefined-builtin
-value in [None, [], (), {}, set()] or
+"""Dump the AST for `node`.
-isinstance(value, (string_class, int, float))
-)
+This recursively walks the AST, printing a readable version.
-def ast_dump(node, depth=0):
+"""
-"""Dump the AST for `node`.
+indent = " " * depth
+lineno = getattr(node, "lineno", None)
-This recursively walks the AST, printing a readable version.
+if lineno is not None:
+linemark = f" @ {node.lineno},{node.col_offset}"
-"""
+if hasattr(node, "end_lineno"):
-indent = " " * depth
+linemark += ":"
-if not isinstance(node, ast.AST):
+if node.end_lineno != node.lineno:
-print("{}<{} {!r}>".format(indent, node.__class__.__name__, node))
+linemark += f"{node.end_lineno},"
-return
+linemark += f"{node.end_col_offset}"
+else:
-lineno = getattr(node, "lineno", None)
+linemark = ""
-if lineno is not None:
+head = f"{indent}<{node.__class__.__name__}{linemark}"
-linemark = " @ {}".format(node.lineno)
-else:
+named_fields = [
-linemark = ""
+(name, value)
-head = "{}<{}{}".format(indent, node.__class__.__name__, linemark)
+for name, value in ast.iter_fields(node)
+if name not in SKIP_DUMP_FIELDS
-named_fields = [
+]
-(name, value)
+if not named_fields:
-for name, value in ast.iter_fields(node)
+print(f"{head}>")
-if name not in SKIP_DUMP_FIELDS
+elif len(named_fields) == 1 and _is_simple_value(named_fields[0][1]):
-]
+field_name, value = named_fields[0]
-if not named_fields:
+print(f"{head} {field_name}: {value!r}>")
-print("{}>".format(head))
+else:
-elif len(named_fields) == 1 and _is_simple_value(named_fields[0][1]):
+print(head)
-field_name, value = named_fields[0]
+if 0:
-print("{} {}: {!r}>".format(head, field_name, value))
+print("{}# mro: {}".format(
-else:
+indent, ", ".join(c.__name__ for c in node.__class__.__mro__[1:]),
-print(head)
+))
-if 0:
+next_indent = indent + "    "
-print("{}# mro: {}".format(
+for field_name, value in named_fields:
-indent, ", ".join(c.__name__ for c in node.__class__.__mro__[1:]),
+prefix = f"{next_indent}{field_name}:"
-))
+if _is_simple_value(value):
-next_indent = indent + "    "
+print(f"{prefix} {value!r}")
-for field_name, value in named_fields:
+elif isinstance(value, list):
-prefix = "{}{}:".format(next_indent, field_name)
+print(f"{prefix} [")
-if _is_simple_value(value):
+for n in value:
-print("{} {!r}".format(prefix, value))
+if _is_simple_value(n):
-elif isinstance(value, list):
+print(f"{next_indent}    {n!r}")
-print("{} [".format(prefix))
+else:
-for n in value:
+ast_dump(n, depth + 8, print=print)
-ast_dump(n, depth + 8)
+print(f"{next_indent}]")
-print("{}]".format(next_indent))
+else:
-else:
+print(prefix)
-print(prefix)
+ast_dump(value, depth + 8, print=print)
-ast_dump(value, depth + 8)
+print(f"{indent}>")
-print("{}>".format(indent))

Mercurial Repositories > eric / file comparison

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

eric7/DebugClients/Python/coverage/parser.py