coverage 7.6.7__cp311-cp311-win_amd64.whl → 7.11.1__cp311-cp311-win_amd64.whl

coverage/parser.py

@@ -6,18 +6,16 @@
 from __future__ import annotations
 
 import ast
-import functools
 import collections
+import functools
 import os
 import re
-import sys
 import token
 import tokenize
-
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass
 from types import CodeType
-from typing import cast, Callable, Optional, Protocol
+from typing import Callable, Optional, Protocol, cast
 
 from coverage import env
 from coverage.bytecode import code_objects
@@ -37,6 +35,7 @@ class PythonParser:
     involved.
 
     """
+
     def __init__(
         self,
         text: str | None = None,
@@ -55,6 +54,7 @@ class PythonParser:
             self.text: str = text
         else:
             from coverage.python import get_python_source
+
             try:
                 self.text = get_python_source(self.filename)
             except OSError as err:
@@ -92,7 +92,7 @@ class PythonParser:
 
         # A dict mapping line numbers to lexical statement starts for
         # multi-line statements.
-        self._multiline: dict[TLineNo, TLineNo] = {}
+        self.multiline_map: dict[TLineNo, TLineNo] = {}
 
         # Lazily-created arc data, and missing arc descriptions.
         self._all_arcs: set[TArc] | None = None
@@ -113,9 +113,11 @@ class PythonParser:
         last_start_line = 0
         for match in re.finditer(regex, self.text, flags=re.MULTILINE):
             start, end = match.span()
-            start_line = last_start_line + self.text.count('\n', last_start, start)
-            end_line = last_start_line + self.text.count('\n', last_start, end)
-            matches.update(self._multiline.get(i, i) for i in range(start_line + 1, end_line + 2))
+            start_line = last_start_line + self.text.count("\n", last_start, start)
+            end_line = last_start_line + self.text.count("\n", last_start, end)
+            matches.update(
+                self.multiline_map.get(i, i) for i in range(start_line + 1, end_line + 2)
+            )
             last_start = start
             last_start_line = start_line
         return matches
@@ -147,20 +149,23 @@ class PythonParser:
         assert self.text is not None
         tokgen = generate_tokens(self.text)
         for toktype, ttext, (slineno, _), (elineno, _), ltext in tokgen:
-            if self.show_tokens:                # pragma: debugging
-                print("%10s %5s %-20r %r" % (
-                    tokenize.tok_name.get(toktype, toktype),
-                    nice_pair((slineno, elineno)), ttext, ltext,
-                ))
+            if self.show_tokens:  # pragma: debugging
+                print(
+                    "%10s %5s %-20r %r"
+                    % (
+                        tokenize.tok_name.get(toktype, toktype),
+                        nice_pair((slineno, elineno)),
+                        ttext,
+                        ltext,
+                    )
+                )
             if toktype == token.INDENT:
                 indent += 1
             elif toktype == token.DEDENT:
                 indent -= 1
             elif toktype == token.OP:
                 if ttext == ":" and nesting == 0:
-                    should_exclude = (
-                        self.excluded.intersection(range(first_line, elineno + 1))
-                    )
+                    should_exclude = self.excluded.intersection(range(first_line, elineno + 1))
                     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
@@ -177,8 +182,8 @@ class PythonParser:
                     # We're at the end of a line, and we've ended on a
                     # different line than the first line of the statement,
                     # so record a multi-line range.
-                    for l in range(first_line, elineno+1):
-                        self._multiline[l] = first_line
+                    for l in range(first_line, elineno + 1):
+                        self.multiline_map[l] = first_line
                 first_line = 0
 
             if ttext.strip() and toktype != tokenize.COMMENT:
@@ -198,12 +203,6 @@ class PythonParser:
             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:
-            self._multiline[1] = min(self.raw_statements)
-
         self.excluded = self.first_lines(self.excluded)
 
         # AST lets us find classes, docstrings, and decorator-affected
@@ -233,9 +232,9 @@ class PythonParser:
     def first_line(self, lineno: TLineNo) -> TLineNo:
         """Return the first line number of the statement including `lineno`."""
         if lineno < 0:
-            lineno = -self._multiline.get(-lineno, -lineno)
+            lineno = -self.multiline_map.get(-lineno, -lineno)
         else:
-            lineno = self._multiline.get(lineno, lineno)
+            lineno = self.multiline_map.get(lineno, lineno)
         return lineno
 
     def first_lines(self, linenos: Iterable[TLineNo]) -> set[TLineNo]:
@@ -267,12 +266,12 @@ class PythonParser:
             self._raw_parse()
         except (tokenize.TokenError, IndentationError, SyntaxError) as err:
             if hasattr(err, "lineno"):
-                lineno = err.lineno         # IndentationError
+                lineno = err.lineno  # IndentationError
             else:
-                lineno = err.args[1][0]     # TokenError
+                lineno = err.args[1][0]  # TokenError
             raise NotPython(
-                f"Couldn't parse '{self.filename}' as Python source: " +
-                f"{err.args[0]!r} at line {lineno}",
+                f"Couldn't parse '{self.filename}' as Python source: "
+                + f"{err.args[0]!r} at line {lineno}",
             ) from err
 
         ignore = self.excluded | self.raw_docstrings
@@ -298,12 +297,15 @@ class PythonParser:
 
         """
         assert self._ast_root is not None
-        aaa = AstArcAnalyzer(self.filename, self._ast_root, self.raw_statements, self._multiline)
+        aaa = AstArcAnalyzer(self.filename, self._ast_root, self.raw_statements, self.multiline_map)
         aaa.analyze()
+        arcs = aaa.arcs
         self._with_jump_fixers = aaa.with_jump_fixers()
+        if self._with_jump_fixers:
+            arcs = self.fix_with_jumps(arcs)
 
         self._all_arcs = set()
-        for l1, l2 in self.fix_with_jumps(aaa.arcs):
+        for l1, l2 in arcs:
             fl1 = self.first_line(l1)
             fl2 = self.first_line(l2)
             if fl1 != fl2:
@@ -312,20 +314,41 @@ class PythonParser:
         self._missing_arc_fragments = aaa.missing_arc_fragments
 
     def fix_with_jumps(self, arcs: Iterable[TArc]) -> set[TArc]:
-        """Adjust arcs to fix jumps leaving `with` statements."""
+        """Adjust arcs to fix jumps leaving `with` statements.
+
+        Consider this code:
+
+            with open("/tmp/test", "w") as f1:
+                a = 2
+                b = 3
+            print(4)
+
+        In 3.10+, we get traces for lines 1, 2, 3, 1, 4.  But we want to present
+        it to the user as if it had been 1, 2, 3, 4.  The arc 3->1 should be
+        replaced with 3->4, and 1->4 should be removed.
+
+        For this code, the fixers dict is {(3, 1): ((1, 4), (3, 4))}.  The key
+        is the actual measured arc from the end of the with block back to the
+        start of the with-statement.  The values are start_next (the with
+        statement to the next statement after the with), and end_next (the end
+        of the with-statement to the next statement after the with).
+
+        With nested with-statements, we have to trace through a few levels to
+        correct a longer chain of arcs.
+
+        """
         to_remove = set()
         to_add = set()
         for arc in arcs:
             if arc in self._with_jump_fixers:
-                start = arc[0]
+                end0 = arc[0]
                 to_remove.add(arc)
-                start_next, prev_next = self._with_jump_fixers[arc]
+                start_next, end_next = self._with_jump_fixers[arc]
                 while start_next in self._with_jump_fixers:
                     to_remove.add(start_next)
-                    start_next, prev_next = self._with_jump_fixers[start_next]
-                    to_remove.add(prev_next)
-                to_add.add((start, prev_next[1]))
-                to_remove.add(arc)
+                    start_next, end_next = self._with_jump_fixers[start_next]
+                    to_remove.add(end_next)
+                to_add.add((end0, end_next[1]))
                 to_remove.add(start_next)
         arcs = (set(arcs) | to_add) - to_remove
         return arcs
@@ -413,39 +436,26 @@ class ByteParser:
 
         The iteration includes `self` as its first value.
 
+        We skip code objects named `__annotate__` since they are deferred
+        annotations that usually are never run.  If there are errors in the
+        annotations, they will be caught by type checkers or other tools that
+        use annotations.
+
         """
-        return (ByteParser(self.text, code=c) for c in code_objects(self.code))
+        return (
+            ByteParser(self.text, code=c)
+            for c in code_objects(self.code)
+            if c.co_name != "__annotate__"
+        )
 
     def _line_numbers(self) -> Iterable[TLineNo]:
         """Yield the line numbers possible in this code object.
 
-        Uses co_lnotab described in Python/compile.c to find the
-        line numbers.  Produces a sequence: l0, l1, ...
+        Uses co_lines() to produce a sequence: l0, l1, ...
         """
-        if hasattr(self.code, "co_lines"):
-            # PYVERSIONS: new in 3.10
-            for _, _, line in self.code.co_lines():
-                if line:
-                    yield line
-        else:
-            # Adapted from dis.py in the standard library.
-            byte_increments = self.code.co_lnotab[0::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):
-                if byte_incr:
-                    if line_num != last_line_num:
-                        yield line_num
-                        last_line_num = line_num
-                    byte_num += byte_incr
-                if line_incr >= 0x80:
-                    line_incr -= 0x100
-                line_num += line_incr
-            if line_num != last_line_num:
-                yield line_num
+        for _, _, line in self.code.co_lines():
+            if line:
+                yield line
 
     def _find_statements(self) -> Iterable[TLineNo]:
         """Find the statements in `self.code`.
@@ -463,6 +473,7 @@ class ByteParser:
 # AST analysis
 #
 
+
 @dataclass(frozen=True, order=True)
 class ArcStart:
     """The information needed to start an arc.
@@ -493,12 +504,14 @@ class ArcStart:
     "line 1 didn't jump to line 2 because the condition on line 1 was never true."
 
     """
+
     lineno: TLineNo
     cause: str = ""
 
 
 class TAddArcFn(Protocol):
     """The type for AstArcAnalyzer.add_arc()."""
+
     def __call__(
         self,
         start: TLineNo,
@@ -521,6 +534,7 @@ class TAddArcFn(Protocol):
 
 TArcFragments = dict[TArc, list[tuple[Optional[str], Optional[str]]]]
 
+
 class Block:
     """
     Blocks need to handle various exiting statements in their own ways.
@@ -530,6 +544,7 @@ class Block:
     exits are handled, or False if the search should continue up the block
     stack.
     """
+
     # pylint: disable=unused-argument
     def process_break_exits(self, exits: set[ArcStart], add_arc: TAddArcFn) -> bool:
         """Process break exits."""
@@ -550,6 +565,7 @@ class Block:
 
 class LoopBlock(Block):
     """A block on the block stack representing a `for` or `while` loop."""
+
     def __init__(self, start: TLineNo) -> None:
         # The line number where the loop starts.
         self.start = start
@@ -568,6 +584,7 @@ class LoopBlock(Block):
 
 class FunctionBlock(Block):
     """A block on the block stack representing a function definition."""
+
     def __init__(self, start: TLineNo, name: str) -> None:
         # The line number where the function starts.
         self.start = start
@@ -577,7 +594,9 @@ class FunctionBlock(Block):
     def process_raise_exits(self, exits: set[ArcStart], add_arc: TAddArcFn) -> bool:
         for xit in exits:
             add_arc(
-                xit.lineno, -self.start, xit.cause,
+                xit.lineno,
+                -self.start,
+                xit.cause,
                 f"except from function {self.name!r}",
             )
         return True
@@ -585,7 +604,9 @@ class FunctionBlock(Block):
     def process_return_exits(self, exits: set[ArcStart], add_arc: TAddArcFn) -> bool:
         for xit in exits:
             add_arc(
-                xit.lineno, -self.start, xit.cause,
+                xit.lineno,
+                -self.start,
+                xit.cause,
                 f"return from function {self.name!r}",
             )
         return True
@@ -593,6 +614,7 @@ class FunctionBlock(Block):
 
 class TryBlock(Block):
     """A block on the block stack representing a `try` block."""
+
     def __init__(self, handler_start: TLineNo | None, final_start: TLineNo | None) -> None:
         # The line number of the first "except" handler, if any.
         self.handler_start = handler_start
@@ -606,18 +628,33 @@ class TryBlock(Block):
         return True
 
 
-class NodeList(ast.AST):
-    """A synthetic fictitious node, containing a sequence of nodes.
+# TODO: Shouldn't the cause messages join with "and" instead of "or"?
 
-    This is used when collapsing optimized if-statements, to represent the
-    unconditional execution of one of the clauses.
 
-    """
-    def __init__(self, body: Sequence[ast.AST]) -> None:
-        self.body = body
-        self.lineno = body[0].lineno    # type: ignore[attr-defined]
+def is_constant_test_expr(node: ast.AST) -> tuple[bool, bool]:
+    """Is this a compile-time constant test expression?
 
-# TODO: Shouldn't the cause messages join with "and" instead of "or"?
+    We don't try to mimic all of CPython's optimizations.  We just have to
+    handle the kinds of constant expressions people might actually use.
+
+    """
+    match node:
+        case ast.Constant():
+            return True, bool(node.value)
+        case ast.Name():
+            if node.id in ["True", "False", "None", "__debug__"]:
+                return True, eval(node.id)  # pylint: disable=eval-used
+        case ast.UnaryOp():
+            if isinstance(node.op, ast.Not):
+                is_constant, val = is_constant_test_expr(node.operand)
+                return is_constant, not val
+        case ast.BoolOp():
+            rets = [is_constant_test_expr(v) for v in node.values]
+            is_constant = all(is_const for is_const, _ in rets)
+            if is_constant:
+                op = any if isinstance(node.op, ast.Or) else all
+                return True, op(v for _, v in rets)
+    return False, False
 
 
 class AstArcAnalyzer:
@@ -650,7 +687,6 @@ class AstArcAnalyzer:
     ) -> None:
         self.filename = filename
         self.root_node = root_node
-        # TODO: I think this is happening in too many places.
         self.statements = {multiline.get(l, l) for l in statements}
         self.multiline = multiline
 
@@ -658,7 +694,7 @@ class AstArcAnalyzer:
         # $set_env.py: COVERAGE_AST_DUMP - Dump the AST nodes when parsing code.
         dump_ast = bool(int(os.getenv("COVERAGE_AST_DUMP", "0")))
 
-        if dump_ast:                                # pragma: debugging
+        if dump_ast:  # pragma: debugging
             # Dump the AST so that failing tests have helpful output.
             print(f"Statements: {self.statements}")
             print(f"Multiline map: {self.multiline}")
@@ -684,22 +720,19 @@ class AstArcAnalyzer:
         """Examine the AST tree from `self.root_node` to determine possible arcs."""
         for node in ast.walk(self.root_node):
             node_name = node.__class__.__name__
-            code_object_handler = getattr(self, "_code_object__" + node_name, None)
+            code_object_handler = getattr(self, f"_code_object__{node_name}", None)
             if code_object_handler is not None:
                 code_object_handler(node)
 
     def with_jump_fixers(self) -> dict[TArc, tuple[TArc, TArc]]:
         """Get a dict with data for fixing jumps out of with statements.
 
-        Returns a dict.  The keys are arcs leaving a with statement by jumping
+        Returns a dict.  The keys are arcs leaving a with-statement by jumping
         back to its start.  The values are pairs: first, the arc from the start
         to the next statement, then the arc that exits the with without going
         to the start.
 
         """
-        if not env.PYBEHAVIOR.exit_through_with:
-            return {}
-
         fixers = {}
         with_nexts = {
             arc
@@ -712,9 +745,9 @@ class AstArcAnalyzer:
                 continue
             assert len(nexts) == 1, f"Expected one arc, got {nexts} with {start = }"
             nxt = nexts.pop()
-            prvs = {arc[0] for arc in self.with_exits if arc[1] == start}
-            for prv in prvs:
-                fixers[(prv, start)] = ((start, nxt), (prv, nxt))
+            ends = {arc[0] for arc in self.with_exits if arc[1] == start}
+            for end in ends:
+                fixers[(end, start)] = ((start, nxt), (end, nxt))
         return fixers
 
     # Code object dispatchers: _code_object__*
@@ -755,7 +788,7 @@ class AstArcAnalyzer:
         action_msg: str | None = None,
     ) -> None:
         """Add an arc, including message fragments to use if it is missing."""
-        if self.debug:                      # pragma: debugging
+        if self.debug:  # pragma: debugging
             print(f"Adding possible arc: ({start}, {end}): {missing_cause_msg!r}, {action_msg!r}")
             print(short_stack(), end="\n\n")
         self.arcs.add((start, end))
@@ -778,12 +811,13 @@ class AstArcAnalyzer:
         node_name = node.__class__.__name__
         handler = cast(
             Optional[Callable[[ast.AST], TLineNo]],
-            getattr(self, "_line__" + node_name, None),
+            getattr(self, f"_line__{node_name}", None),
         )
         if handler is not None:
-            return handler(node)
+            line = handler(node)
         else:
-            return node.lineno      # type: ignore[attr-defined, no-any-return]
+            line = node.lineno  # type: ignore[attr-defined]
+        return self.multiline.get(line, line)
 
     # First lines: _line__*
     #
@@ -823,19 +857,22 @@ class AstArcAnalyzer:
         else:
             return node.lineno
 
-    def _line__Module(self, node: ast.Module) -> TLineNo:
-        if env.PYBEHAVIOR.module_firstline_1:
-            return 1
-        elif node.body:
-            return self.line_for_node(node.body[0])
-        else:
-            # Empty modules have no line number, they always start at 1.
-            return 1
+    def _line__Module(self, node: ast.Module) -> TLineNo:  # pylint: disable=unused-argument
+        return 1
 
     # The node types that just flow to the next node with no complications.
     OK_TO_DEFAULT = {
-        "AnnAssign", "Assign", "Assert", "AugAssign", "Delete", "Expr", "Global",
-        "Import", "ImportFrom", "Nonlocal", "Pass",
+        "AnnAssign",
+        "Assign",
+        "Assert",
+        "AugAssign",
+        "Delete",
+        "Expr",
+        "Global",
+        "Import",
+        "ImportFrom",
+        "Nonlocal",
+        "Pass",
     }
 
     def node_exits(self, node: ast.AST) -> set[ArcStart]:
@@ -858,7 +895,7 @@ class AstArcAnalyzer:
         node_name = node.__class__.__name__
         handler = cast(
             Optional[Callable[[ast.AST], set[ArcStart]]],
-            getattr(self, "_handle__" + node_name, None),
+            getattr(self, f"_handle__{node_name}", None),
         )
         if handler is not None:
             arc_starts = handler(node)
@@ -867,7 +904,7 @@ class AstArcAnalyzer:
             # statement), or it's something we overlooked.
             if env.TESTING:
                 if node_name not in self.OK_TO_DEFAULT:
-                    raise RuntimeError(f"*** Unhandled: {node}")        # pragma: only failure
+                    raise RuntimeError(f"*** Unhandled: {node}")  # pragma: only failure
 
             # Default for simple statements: one exit from this node.
             arc_starts = {ArcStart(self.line_for_node(node))}
@@ -905,111 +942,13 @@ class AstArcAnalyzer:
         # the next node.
         for body_node in body:
             lineno = self.line_for_node(body_node)
-            first_line = self.multiline.get(lineno, lineno)
-            if first_line not in self.statements:
-                maybe_body_node = self.find_non_missing_node(body_node)
-                if maybe_body_node is None:
-                    continue
-                body_node = maybe_body_node
-                lineno = self.line_for_node(body_node)
+            if lineno not in self.statements:
+                continue
             for prev_start in prev_starts:
                 self.add_arc(prev_start.lineno, lineno, prev_start.cause)
             prev_starts = self.node_exits(body_node)
         return prev_starts
 
-    def find_non_missing_node(self, node: ast.AST) -> ast.AST | None:
-        """Search `node` looking for a child that has not been optimized away.
-
-        This might return the node you started with, or it will work recursively
-        to find a child node in self.statements.
-
-        Returns a node, or None if none of the node remains.
-
-        """
-        # This repeats work just done in process_body, but this duplication
-        # means we can avoid a function call in the 99.9999% case of not
-        # optimizing away statements.
-        lineno = self.line_for_node(node)
-        first_line = self.multiline.get(lineno, lineno)
-        if first_line in self.statements:
-            return node
-
-        missing_fn = cast(
-            Optional[Callable[[ast.AST], Optional[ast.AST]]],
-            getattr(self, "_missing__" + node.__class__.__name__, None),
-        )
-        if missing_fn is not None:
-            ret_node = missing_fn(node)
-        else:
-            ret_node = None
-        return ret_node
-
-    # Missing nodes: _missing__*
-    #
-    # Entire statements can be optimized away by Python. They will appear in
-    # the AST, but not the bytecode.  These functions are called (by
-    # find_non_missing_node) to find a node to use instead of the missing
-    # node.  They can return None if the node should truly be gone.
-
-    def _missing__If(self, node: ast.If) -> ast.AST | None:
-        # If the if-node is missing, then one of its children might still be
-        # here, but not both. So return the first of the two that isn't missing.
-        # Use a NodeList to hold the clauses as a single node.
-        non_missing = self.find_non_missing_node(NodeList(node.body))
-        if non_missing:
-            return non_missing
-        if node.orelse:
-            return self.find_non_missing_node(NodeList(node.orelse))
-        return None
-
-    def _missing__NodeList(self, node: NodeList) -> ast.AST | None:
-        # A NodeList might be a mixture of missing and present nodes. Find the
-        # ones that are present.
-        non_missing_children = []
-        for child in node.body:
-            maybe_child = self.find_non_missing_node(child)
-            if maybe_child is not None:
-                non_missing_children.append(maybe_child)
-
-        # Return the simplest representation of the present children.
-        if not non_missing_children:
-            return None
-        if len(non_missing_children) == 1:
-            return non_missing_children[0]
-        return NodeList(non_missing_children)
-
-    def _missing__While(self, node: ast.While) -> ast.AST | None:
-        body_nodes = self.find_non_missing_node(NodeList(node.body))
-        if not body_nodes:
-            return None
-        # Make a synthetic While-true node.
-        new_while = ast.While()                     # type: ignore[call-arg]
-        new_while.lineno = body_nodes.lineno        # type: ignore[attr-defined]
-        new_while.test = ast.Name()                 # type: ignore[call-arg]
-        new_while.test.lineno = body_nodes.lineno   # type: ignore[attr-defined]
-        new_while.test.id = "True"
-        assert hasattr(body_nodes, "body")
-        new_while.body = body_nodes.body
-        new_while.orelse = []
-        return new_while
-
-    def is_constant_expr(self, node: ast.AST) -> str | None:
-        """Is this a compile-time constant?"""
-        node_name = node.__class__.__name__
-        if node_name in ["Constant", "NameConstant", "Num"]:
-            return "Num"
-        elif isinstance(node, ast.Name):
-            if node.id in ["True", "False", "None", "__debug__"]:
-                return "Name"
-        return None
-
-    # In the fullness of time, these might be good tests to write:
-    #   while EXPR:
-    #   while False:
-    #   listcomps hidden deep in other expressions
-    #   listcomps hidden in lists: x = [[i for i in range(10)]]
-    #   nested function definitions
-
     # Exit processing: process_*_exits
     #
     # These functions process the four kinds of jump exits: break, continue,
@@ -1020,13 +959,13 @@ class AstArcAnalyzer:
 
     def process_break_exits(self, exits: set[ArcStart]) -> None:
         """Add arcs due to jumps from `exits` being breaks."""
-        for block in self.nearest_blocks():                         # pragma: always breaks
+        for block in self.nearest_blocks():  # pragma: always breaks
             if block.process_break_exits(exits, self.add_arc):
                 break
 
     def process_continue_exits(self, exits: set[ArcStart]) -> None:
         """Add arcs due to jumps from `exits` being continues."""
-        for block in self.nearest_blocks():                         # pragma: always breaks
+        for block in self.nearest_blocks():  # pragma: always breaks
             if block.process_continue_exits(exits, self.add_arc):
                 break
 
@@ -1038,7 +977,7 @@ class AstArcAnalyzer:
 
     def process_return_exits(self, exits: set[ArcStart]) -> None:
         """Add arcs due to jumps from `exits` being returns."""
-        for block in self.nearest_blocks():                         # pragma: always breaks
+        for block in self.nearest_blocks():  # pragma: always breaks
             if block.process_return_exits(exits, self.add_arc):
                 break
 
@@ -1068,8 +1007,8 @@ class AstArcAnalyzer:
             last = None
             for dec_node in decs:
                 dec_start = self.line_for_node(dec_node)
-                if last is not None and dec_start != last:  # type: ignore[unreachable]
-                    self.add_arc(last, dec_start)           # type: ignore[unreachable]
+                if last is not None and dec_start != last:
+                    self.add_arc(last, dec_start)
                 last = dec_start
             assert last is not None
             self.add_arc(last, main_line)
@@ -1079,8 +1018,6 @@ class AstArcAnalyzer:
             # not what we'd think of as the first line in the statement, so map
             # it to the first one.
             assert node.body, f"Oops: {node.body = } in {self.filename}@{node.lineno}"
-            body_start = self.line_for_node(node.body[0])
-            body_start = self.multiline.get(body_start, body_start)
         # The body is handled in collect_arcs.
         assert last is not None
         return {ArcStart(last)}
@@ -1120,48 +1057,44 @@ class AstArcAnalyzer:
 
     def _handle__If(self, node: ast.If) -> set[ArcStart]:
         start = self.line_for_node(node.test)
-        from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
-        exits = self.process_body(node.body, from_start=from_start)
-        from_start = ArcStart(start, cause="the condition on line {lineno} was always true")
-        exits |= self.process_body(node.orelse, from_start=from_start)
+        constant_test, val = is_constant_test_expr(node.test)
+        exits = set()
+        if not constant_test or val:
+            from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
+            exits |= self.process_body(node.body, from_start=from_start)
+        if not constant_test or not val:
+            from_start = ArcStart(start, cause="the condition on line {lineno} was always true")
+            exits |= self.process_body(node.orelse, from_start=from_start)
         return exits
 
-    if sys.version_info >= (3, 10):
-        def _handle__Match(self, node: ast.Match) -> set[ArcStart]:
-            start = self.line_for_node(node)
-            last_start = start
-            exits = set()
-            for case in node.cases:
-                case_start = self.line_for_node(case.pattern)
-                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.process_body(case.body, from_start=from_start)
-                last_start = case_start
-
-            # case is now the last case, check for wildcard match.
-            pattern = case.pattern      # pylint: disable=undefined-loop-variable
-            while isinstance(pattern, ast.MatchOr):
-                pattern = pattern.patterns[-1]
-            while isinstance(pattern, ast.MatchAs) and pattern.pattern is not None:
-                pattern = pattern.pattern
-            had_wildcard = (
-                isinstance(pattern, ast.MatchAs)
-                and pattern.pattern is None
-                and case.guard is None  # pylint: disable=undefined-loop-variable
+    def _handle__Match(self, node: ast.Match) -> set[ArcStart]:
+        start = self.line_for_node(node)
+        last_start = start
+        exits = set()
+        for case in node.cases:
+            case_start = self.line_for_node(case.pattern)
+            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.process_body(case.body, from_start=from_start)
+            last_start = case_start
+
+        # case is now the last case, check for wildcard match.
+        pattern = case.pattern  # pylint: disable=undefined-loop-variable
+        while isinstance(pattern, ast.MatchOr):
+            pattern = pattern.patterns[-1]
+        while isinstance(pattern, ast.MatchAs) and pattern.pattern is not None:
+            pattern = pattern.pattern
+        had_wildcard = (
+            isinstance(pattern, ast.MatchAs) and pattern.pattern is None and case.guard is None  # pylint: disable=undefined-loop-variable
+        )
 
-            if not had_wildcard:
-                exits.add(
-                    ArcStart(case_start, cause="the pattern on line {lineno} always matched"),
-                )
-            return exits
-
-    def _handle__NodeList(self, node: NodeList) -> set[ArcStart]:
-        start = self.line_for_node(node)
-        exits = self.process_body(node.body, from_start=ArcStart(start))
+        if not had_wildcard:
+            exits.add(
+                ArcStart(case_start, cause="the pattern on line {lineno} always matched"),
+            )
         return exits
 
     def _handle__Raise(self, node: ast.Raise) -> set[ArcStart]:
@@ -1235,14 +1168,7 @@ class AstArcAnalyzer:
 
     def _handle__While(self, node: ast.While) -> set[ArcStart]:
         start = to_top = self.line_for_node(node.test)
-        constant_test = self.is_constant_expr(node.test)
-        top_is_body0 = False
-        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])
+        constant_test, _ = is_constant_test_expr(node.test)
         self.block_stack.append(LoopBlock(start=to_top))
         from_start = ArcStart(start, cause="the condition on line {lineno} was never true")
         exits = self.process_body(node.body, from_start=from_start)
@@ -1267,22 +1193,20 @@ class AstArcAnalyzer:
             starts = [self.line_for_node(item.context_expr) for item in node.items]
         else:
             starts = [self.line_for_node(node)]
-        if env.PYBEHAVIOR.exit_through_with:
-            for start in starts:
-                self.current_with_starts.add(start)
-                self.all_with_starts.add(start)
+        for start in starts:
+            self.current_with_starts.add(start)
+            self.all_with_starts.add(start)
 
         exits = self.process_body(node.body, from_start=ArcStart(starts[-1]))
 
-        if env.PYBEHAVIOR.exit_through_with:
-            start = starts[-1]
-            self.current_with_starts.remove(start)
-            with_exit = {ArcStart(start)}
-            if exits:
-                for xit in exits:
-                    self.add_arc(xit.lineno, start)
-                    self.with_exits.add((xit.lineno, start))
-                exits = with_exit
+        start = starts[-1]
+        self.current_with_starts.remove(start)
+        with_exit = {ArcStart(start)}
+        if exits:
+            for xit in exits:
+                self.add_arc(xit.lineno, start)
+                self.with_exits.add((xit.lineno, start))
+            exits = with_exit
 
         return exits