pycrefine 1.1.1__py3-none-any.whl

pycrefine/__init__.py

@@ -0,0 +1,65 @@
+"""pycrefine: a Python .pyc decompiler that rebuilds source code from compiled bytecode.
+
+Every name that used to live in the single-file ``pycrefine`` module is re-exported here,
+so ``import pycrefine`` and ``from pycrefine import ...`` behave as before.
+"""
+__version__ = "1.1.1"
+
+from ._constants import (  # noqa: F401
+    _AUG_ASSIGN_MAP,
+    _COMPOUND_EXPR_OPS,
+    _COMPOUND_SKIP,
+    _GENERIC_SKIP_OPS,
+    _INPLACE_ASSIGN_MAP,
+    _IS_COMP_GEN_SKIP,
+    _IS_COMP_GEN_STOP,
+    _MAX_TERNARY_MINI_SEARCH_WINDOW,
+    _MAX_TERNARY_SEARCH_WINDOW,
+    _MAX_TERNARY_SHORT_SEARCH_WINDOW,
+    _MAX_WITH_EXIT_SEARCH_WINDOW,
+    _NO_INDENT_TYPES,
+    _NO_PASS_TYPES,
+    _STATEMENT_BOUNDARY_OPS,
+    _TERNARY_PURE,
+    _TERNARY_SKIP,
+    _TERNARY_STORES,
+    _TERNARY_TERM,
+    _TRY_HANDLER_EXIT_OPS,
+    _TRY_LOAD_OPS,
+    _TRY_LOOP_HEADS,
+    _TRY_SKIP_NOP,
+    _UNARY_SYMBOLS,
+    _WHILE_TRIVIAL_OPS,
+)
+from .expr import StackNULL, _BoolExpr, _CollectionAccumSentinel, _unary_operand  # noqa: F401
+from .instructions import (  # noqa: F401
+    BytecodeInstruction,
+    _const_repr,
+    _is_anonymous_func_body,
+    _render_func_tuple,
+)
+from .postprocess import (  # noqa: F401
+    _block_opener_keyword,
+    _collect_multiline_header,
+    _line_is_in_triple_quoted_string,
+    collapse_chained_comparisons,
+    flatten_elif,
+    post_process_source,
+)
+from .codeobj import ForeignCode, _is_code  # noqa: F401
+from .decompiler.base import DecompilerBase  # noqa: F401
+from .decompiler.generic import DecompilerGeneric, _pick_decompiler_class  # noqa: F401
+from .opcodes.py39 import _OPCODES_39  # noqa: F401
+from .decompiler.py39 import Decompiler39  # noqa: F401
+from .decompiler.py311 import Decompiler311Plus  # noqa: F401
+from .decompiler.py314 import Decompiler314  # noqa: F401
+from .loader import (  # noqa: F401
+    MarshalParser,
+    _CO_FAST_CELL,
+    _CO_FAST_FREE,
+    _CO_FAST_LOCAL,
+    _MARSHAL_NULL,
+    get_decompiler,
+)
+from .versions import _get_python_version_from_magic  # noqa: F401
+from .cli import main  # noqa: F401

pycrefine/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

pycrefine/_constants.py

@@ -0,0 +1,136 @@
+"""Shared constant instruction sets, lookup maps and search-window sizes."""
+
+
+# --- Magic Numbers & Search Windows ---
+_MAX_WITH_EXIT_SEARCH_WINDOW = 200
+
+
+_MAX_TERNARY_SEARCH_WINDOW = 20
+
+
+_MAX_TERNARY_SHORT_SEARCH_WINDOW = 12
+
+
+_MAX_TERNARY_MINI_SEARCH_WINDOW = 8
+
+
+# --- Constant Instruction Sets ---
+_NO_PASS_TYPES = frozenset({"exc_cleanup", "finally_wrapper"})
+
+
+_NO_INDENT_TYPES = frozenset({"finally_wrapper"})
+
+
+_UNARY_SYMBOLS = {
+    "UNARY_NEGATIVE": "-", "UNARY_POSITIVE": "+", "UNARY_INVERT": "~", "UNARY_NOT": "not ",
+}
+
+
+_TERNARY_STORES = frozenset(("STORE_FAST", "STORE_NAME", "STORE_GLOBAL", "STORE_DEREF"))
+
+
+_TERNARY_SKIP = frozenset(("CACHE", "RESUME", "NOT_TAKEN", "COPY_FREE_VARS"))
+
+
+_TERNARY_TERM = frozenset(("RETURN_CONST", "RETURN_VALUE"))
+
+
+_TERNARY_PURE = frozenset((
+    "LOAD_FAST", "LOAD_NAME", "LOAD_GLOBAL", "LOAD_CONST", "LOAD_DEREF",
+    "LOAD_SMALL_INT", "LOAD_GLOBAL_MODULE", "LOAD_ATTR", "LOAD_METHOD",
+    "GET_ATTR", "LOAD_FAST_BORROW", "LOAD_FAST_BORROW_LOAD_FAST_BORROW",
+    "LOAD_CONST_BORROW", "CALL", "CALL_FUNCTION", "CALL_METHOD",
+    "COMPARE_OP", "BINARY_OP", "IS_OP", "CONTAINS_OP",
+    "UNARY_NOT", "UNARY_NEGATIVE", "UNARY_POSITIVE", "UNARY_INVERT", "CALL_INTRINSIC_1",
+    "BUILD_TUPLE", "BUILD_LIST", "BUILD_SET", "BUILD_MAP",
+    "PRECALL", "PUSH_NULL", "FORMAT_VALUE", "FORMAT_SIMPLE", "BUILD_STRING",
+    "BINARY_SUBSCR", "TO_BOOL", "BINARY_SLICE", "BUILD_SLICE",
+    # Python 3.9 named binary opcodes (3.11+ uses BINARY_OP instead):
+    "BINARY_ADD", "BINARY_SUBTRACT", "BINARY_MULTIPLY", "BINARY_TRUE_DIVIDE",
+    "BINARY_FLOOR_DIVIDE", "BINARY_MODULO", "BINARY_POWER", "BINARY_LSHIFT",
+    "BINARY_RSHIFT", "BINARY_AND", "BINARY_OR", "BINARY_XOR",
+    "BINARY_MATRIX_MULTIPLY",
+)) | _TERNARY_SKIP | _TERNARY_TERM
+
+
+_COMPOUND_SKIP = frozenset(("CACHE", "RESUME", "NOT_TAKEN", "COPY_FREE_VARS", "PRECALL", "PUSH_NULL"))
+
+
+_COMPOUND_EXPR_OPS = frozenset((
+    "LOAD_FAST", "LOAD_NAME", "LOAD_GLOBAL", "LOAD_CONST", "LOAD_DEREF",
+    "LOAD_SMALL_INT", "LOAD_FAST_BORROW", "LOAD_CONST_BORROW", "LOAD_FAST_BORROW_LOAD_FAST_BORROW",
+    "LOAD_GLOBAL_MODULE", "LOAD_ATTR", "LOAD_METHOD", "GET_ATTR",
+    "CALL", "CALL_FUNCTION", "CALL_METHOD", "COMPARE_OP", "BINARY_OP", "IS_OP", "CONTAINS_OP",
+    "UNARY_NOT", "UNARY_NEGATIVE", "UNARY_POSITIVE", "UNARY_INVERT",
+    "BUILD_TUPLE", "BUILD_LIST", "BUILD_SET", "BUILD_MAP",
+    "TO_BOOL", "FORMAT_VALUE", "FORMAT_SIMPLE", "BUILD_STRING", "BINARY_SUBSCR", "BINARY_SLICE", "BUILD_SLICE",
+    "DUP_TOP", "DUP_TOP_TWO", "ROT_TWO", "ROT_THREE", "ROT_FOUR", "SWAP", "COPY",
+    # Python 3.9 binary opcodes:
+    "BINARY_ADD", "BINARY_SUBTRACT", "BINARY_MULTIPLY", "BINARY_TRUE_DIVIDE",
+    "BINARY_FLOOR_DIVIDE", "BINARY_MODULO", "BINARY_POWER", "BINARY_LSHIFT",
+    "BINARY_RSHIFT", "BINARY_AND", "BINARY_OR", "BINARY_XOR",
+    "BINARY_MATRIX_MULTIPLY"
+)) | _COMPOUND_SKIP
+
+
+_WHILE_TRIVIAL_OPS = frozenset({"NOP", "RESUME", "NOT_TAKEN", "CACHE", "COPY_FREE_VARS"})
+
+
+_STATEMENT_BOUNDARY_OPS = frozenset({
+    "POP_TOP", "POP_ITER", "END_FOR", "RETURN_VALUE", "RETURN_CONST", "RAISE_VARARGS",
+    "RERAISE", "POP_BLOCK", "PUSH_EXC_INFO", "POP_EXCEPT",
+})
+
+
+_TRY_SKIP_NOP = frozenset({"RESUME", "CACHE", "NOT_TAKEN"})
+
+# Placeholders between a protected range's end and the code that follows it (a with
+# block's inlined exit call, a finally copy): skipped when matching positions.
+_FILLER_OPS = frozenset({"NOP", "CACHE"})
+
+
+_TRY_LOAD_OPS = frozenset({"LOAD_NAME", "LOAD_GLOBAL", "LOAD_FAST",
+                          "LOAD_DEREF", "LOAD_SMALL_INT", "LOAD_GLOBAL_MODULE"})
+
+
+_TRY_LOOP_HEADS = frozenset({"FOR_ITER", "GET_ITER", "GET_ANEXT", "GET_AWAITABLE"})
+
+
+_TRY_HANDLER_EXIT_OPS = frozenset({"POP_EXCEPT", "DELETE_FAST", "DELETE_NAME",
+                                  "DELETE_GLOBAL", "STORE_FAST", "STORE_NAME"})
+
+
+_IS_COMP_GEN_SKIP = frozenset({"POP_TOP", "CACHE", "NOP", "RESUME", "COPY", "NOT_TAKEN"})
+
+
+_IS_COMP_GEN_STOP = frozenset({"LOAD_CONST", "LOAD_NAME", "LOAD_FAST", "LOAD_GLOBAL", "LOAD_DEREF", "LOAD_SMALL_INT",
+                              "LOAD_ATTR", "PUSH_NULL", "RERAISE", "RAISE_VARARGS", "RETURN_CONST", "RETURN_VALUE", "JUMP_FORWARD"})
+
+
+_GENERIC_SKIP_OPS = frozenset({"RESUME", "CACHE", "NOP", "NOT_TAKEN", "COPY_FREE_VARS", "EXTENDED_ARG"})
+
+
+# --- Augmented Assignment Opcodes ---
+_AUG_ASSIGN_MAP = {
+    13: "+=",  14: "&=",  15: "//=", 16: "<<=", 17: "@=",
+    18: "*=",  19: "%=",  20: "|=",  21: "**=", 22: ">>=",
+    23: "-=",  24: "/=",  25: "^=",
+}
+
+
+_INPLACE_ASSIGN_MAP = {
+    "INPLACE_ADD": "+=", "INPLACE_SUBTRACT": "-=",
+    "INPLACE_MULTIPLY": "*=", "INPLACE_TRUE_DIVIDE": "/=",
+    "INPLACE_FLOOR_DIVIDE": "//=", "INPLACE_MODULO": "%=",
+    "INPLACE_POWER": "**=", "INPLACE_LSHIFT": "<<=",
+    "INPLACE_RSHIFT": ">>=", "INPLACE_AND": "&=",
+    "INPLACE_OR": "|=", "INPLACE_XOR": "^=",
+    "INPLACE_MATRIX_MULTIPLY": "@=",
+}
+
+
+# --- Value-pushing opcodes (prefixes) ---
+# Instructions that push a value, such as the callee of a call before its arguments;
+# an inlined `with` exit call never directly follows one of them.
+_VALUE_OPS = ("LOAD_", "PUSH_NULL", "CALL", "BINARY_", "BUILD_", "COPY", "GET_", "UNARY_",
+              "COMPARE_", "FORMAT_", "MAKE_FUNCTION", "CONTAINS_OP", "IS_OP")

pycrefine/cli.py

@@ -0,0 +1,53 @@
+"""Command-line interface."""
+import argparse
+import sys
+import traceback
+from .loader import get_decompiler
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="A Python .pyc decompiler that reconstructs readable source code from compiled bytecode."
+    )
+    parser.add_argument("input", help="The .pyc file to decompile")
+    parser.add_argument(
+        "-o", "--output",
+        help="Optional filename to save the decompiled output to. If not supplied, prints to screen."
+    )
+    parser.add_argument(
+        "--beautification-level",
+        choices=['none', 'core', 'aggressive'], default='core',
+        help="Level of code beautification to apply. 'none' does no beautification. 'core' collapses else-if to elif. 'aggressive' is a stub for future use."
+    )
+
+    args = parser.parse_args()
+
+    try:
+        decompiler = get_decompiler(args.input, args.beautification_level)
+        output_text = decompiler.decompile()
+
+        if args.output:
+            try:
+                with open(args.output, "w", encoding="utf-8") as f:
+                    f.write(output_text)
+                print(f"Decompiled output saved to {args.output}", file=sys.stderr)
+            except OSError as e:
+                print(f"Error: Failed to save decompiled output to {args.output}: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            if output_text and output_text.strip():
+                print(output_text)
+            else:
+                print(f"Warning: Decompiler returned no source code for {args.input}", file=sys.stderr)
+                sys.exit(1)
+
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except Exception:
+        traceback.print_exc()
+        sys.exit(1)

pycrefine/codeobj.py

@@ -0,0 +1,26 @@
+"""Code-object helpers shared by the loader and the decompilers (``ForeignCode`` for foreign-version .pyc files)."""
+import types
+from typing import Any
+
+
+class ForeignCode:
+    """
+    A code object read from a .pyc of a different Python version.
+
+    The host interpreter cannot build a real ``types.CodeType`` from another
+    version's bytecode, so the parsed fields are kept as plain ``co_*``
+    attributes. The decompilers only read those attributes.
+    """
+
+    co_name: str
+
+    def __init__(self, **fields: Any):
+        self.__dict__.update(fields)
+
+    def __repr__(self) -> str:
+        return f"<ForeignCode {self.co_name!r}>"
+
+
+def _is_code(obj: Any) -> bool:
+    """True for a host code object or one parsed from another Python version."""
+    return isinstance(obj, (types.CodeType, ForeignCode))

pycrefine/decompiler/base.py

@@ -0,0 +1,258 @@
+"""Base class holding the state every decompiler backend shares."""
+import ast
+import dis
+import sys
+import types
+from typing import Any, List, Optional, Tuple
+from ..instructions import BytecodeInstruction
+
+
+class DecompilerBase:
+    def __init__(self, code_obj: types.CodeType, indent_level: int = 0, beautification_level: str = 'core', target_version: Optional[Tuple[int, int]] = None):
+        self.code_obj = code_obj
+        # Exception table, filled in on first use by _exception_entries(); False = not yet read.
+        self._exception_entries_cache: Any = False
+        self.instructions: List[BytecodeInstruction] = []
+        self.reconstructed: List[str] = []
+        self.indent_level = indent_level
+        self.stack: List[Any] = []
+        self.instructions = list(code_obj.instructions) if hasattr(code_obj, 'instructions') else []
+        self.starts_as_function = indent_level > 0
+        self.blocks: List[Tuple[int, str]] = []  # stack of (end_offset, type)
+        self.pc = 0
+        self.beautification_level = beautification_level
+        self.target_version = target_version or sys.version_info[:2]
+        self._accum_counter = 0
+
+    def _disassemble(self):
+        """Convert code object bytecode into a list of BytecodeInstruction."""
+        for instr in dis.get_instructions(self.code_obj):
+            starts_line = instr.starts_line
+            if isinstance(starts_line, bool):
+                # 3.13+: a flag, with the number in ``line_number``.
+                starts_line = getattr(instr, "line_number", None) if starts_line else None
+            self.instructions.append(BytecodeInstruction(
+                opcode=instr.opcode,
+                opname=instr.opname,
+                arg=instr.arg,
+                argval=instr.argval,
+                offset=instr.offset,
+                starts_line=starts_line,
+                is_jump_target=instr.is_jump_target,
+                argrepr=instr.argrepr,
+            ))
+
+    def decompile(self) -> str:
+        """
+        Decompile the stored code object into a human-readable Python source string.
+
+        Returns:
+            source (str): Reconstructed Python source for the decompiled code object.
+        """
+        raise NotImplementedError("Subclasses must implement decompile()")
+
+    def _fresh_accum_name(self) -> str:
+        """
+        Generate a fresh accumulator variable name that doesn't collide with existing names.
+
+        Returns:
+            str: A unique accumulator name like "_res", "_res1", "_res2", etc.
+        """
+        base_name = "_res"
+        # Collect all existing names from the code object
+        existing_names = set()
+        if hasattr(self.code_obj, 'co_varnames'):
+            existing_names.update(self.code_obj.co_varnames)
+        if hasattr(self.code_obj, 'co_names'):
+            existing_names.update(self.code_obj.co_names)
+
+        # Try base name first
+        if base_name not in existing_names:
+            return base_name
+
+        # Otherwise use counter to generate unique name
+        while True:
+            candidate = f"{base_name}{self._accum_counter}"
+            self._accum_counter += 1
+            if candidate not in existing_names:
+                return candidate
+
+    def _get_jump_target(self, instr: BytecodeInstruction) -> int:
+        """
+        Determine the absolute jump target offset for the given instruction.
+
+        @param instr: The disassembled instruction whose jump target should be resolved.
+        @returns: The target bytecode offset as an integer; returns 0 when no target is available.
+        """
+        if isinstance(instr.argval, int):
+            return instr.argval
+        return int(instr.arg) if (instr.arg is not None) else 0
+
+    def is_effectively_last(self) -> bool:
+        """
+        Determine whether the remaining instructions from the current program counter are only epilogue/handler or otherwise ignorable operations.
+
+        Scans instructions starting at self.pc and treats common epilogue/exception-handler/filler opcodes and trailing `return None` patterns as non-meaningful; returns False if any remaining instruction is considered meaningful.
+
+        Returns:
+            True if no meaningful instructions remain after the current program counter, False otherwise.
+        """
+        # Code the prescans already placed elsewhere (a finally body's re-raise copy,
+        # handler sections rendered at their merge label) is not on the fall-through path.
+        placed = set()
+        for name in ("_finally_body_suppress", "_wrapper_body_suppress", "_handler_section_suppress"):
+            placed |= getattr(self, name, set())
+        # Search ahead from current PC.
+        for i in range(self.pc, len(self.instructions)):
+            instr = self.instructions[i]
+            op = instr.opname
+            if instr.offset in placed:
+                continue
+            # Skip re-raise epilogue, filler, and terminal stack-clearing instructions
+            # common in modern Python (3.11-3.14) exception handlers and epilogues.
+            if op in (
+                "COPY", "POP_EXCEPT", "RERAISE", "CACHE", "RESUME", "PUSH_EXC_INFO",
+                "POP_TOP", "LOAD_CONST", "EXTENDED_ARG", "CHECK_EXC_MATCH",
+                "NOT_TAKEN", "TO_BOOL", "POP_JUMP_IF_TRUE", "POP_JUMP_IF_FALSE",
+                "JUMP_BACKWARD", "JUMP_BACKWARD_NO_INTERRUPT", "NOP"
+            ):
+                continue
+            # Skip subsequent None returns (common in 3.14 multiple exit paths)
+            stack = getattr(self, "stack", None)
+            if op == "RETURN_VALUE" and stack and str(stack[-1]) == "None":
+                continue
+            if op == "RETURN_CONST" and str(instr.argval) == "None":
+                continue
+            return False
+        return True
+
+    def _wrap_negative_literal(self, value: Any) -> str:
+        """
+        Wrap negative numeric literals in parentheses to ensure valid syntax for attribute access or method calls.
+
+        Example: -1 -> (-1). bit_length()
+        """
+        s = str(value)
+        if s.startswith("-"):
+            try:
+                evaluated = ast.literal_eval(s)
+                if isinstance(evaluated, (int, float, complex)):
+                    return f"({s})"
+            except (ValueError, SyntaxError):
+                pass
+        # Also wrap variables with explicit unary minus like (-x) if needed?
+        # Only focus on numeric/complex literals that break attr access:
+        if s.startswith("(-") and s.endswith(")"):
+            return s
+        return s
+
+    def _module_level_return_none(self) -> bool:
+        """
+        Handle a `return None` in code that is not a function body.
+
+        Module and class bodies cannot contain a `return` statement, so every
+        `return None` there is compiler-generated: 3.12+ copies the implicit
+        final return to the end of each branch, and compiles a `break` out of a
+        loop at the end of the module as `return None`. Emits `break` inside a
+        loop and nothing elsewhere.
+
+        Returns:
+            True if the return was handled here, False for function bodies.
+        """
+        if getattr(self.code_obj, "co_flags", 0) & 0x1:   # CO_OPTIMIZED: a function
+            return False
+        here = self.instructions[self.pc - 1].offset if 0 < self.pc <= len(self.instructions) else -1
+        # A loop whose end is at or before this return has already finished (it is
+        # only still on the stack because a block opened inside it ends later).
+        if any(btype in ("for", "while") and end > here for end, btype in getattr(self, "blocks", [])):
+            self._append_reconstructed("break")
+        return True
+
+    def _exception_entries(self) -> Optional[list]:
+        """
+        The code object's exception table (3.11+), computed once; None before 3.11, whose
+        code objects have none (``dis.Bytecode`` has no ``exception_entries`` there).
+        """
+        cached = self._exception_entries_cache
+        if cached is False:
+            try:
+                cached = list(dis.Bytecode(self.code_obj).exception_entries)
+            except (AttributeError, TypeError, ValueError, IndexError):
+                cached = None
+            self._exception_entries_cache = cached
+        return cached
+
+    def _ends_try_before_handlers(self, instr_index: int) -> bool:
+        """
+        True if the return at *instr_index* is the normal exit of a `try` that ends the
+        function: the exception handlers start right after it (3.11+ lays them out after
+        the code they protect), so nothing but handler code follows on any path.
+        """
+        instrs = self.instructions
+        nxt = next((ins for ins in instrs[instr_index + 1:]
+                    if ins.opname not in ("CACHE", "NOP", "EXTENDED_ARG")), None)
+        if nxt is None or nxt.opname != "PUSH_EXC_INFO":
+            return False
+        # A handler that completes jumps to the code after the try statement. If that
+        # is more than the implicit `return None`, the try does not end the function
+        # (``try: ... except E: ... else: return None`` followed by more code).
+        by_offset = {ins.offset: i for i, ins in enumerate(instrs)}
+        for ins in instrs[instr_index + 1:]:
+            if ins.opname not in ("JUMP_FORWARD", "JUMP", "JUMP_NO_INTERRUPT"):
+                continue
+            k = by_offset.get(self._get_jump_target(ins))
+            while k is not None and k < len(instrs) and instrs[k].opname in ("CACHE", "NOP", "EXTENDED_ARG"):
+                k += 1
+            if k is None or k >= len(instrs):
+                continue
+            target = instrs[k]
+            implicit = (target.opname == "RETURN_CONST" and target.argval is None) or (
+                target.opname == "LOAD_CONST" and target.argval is None
+                and k + 1 < len(instrs) and instrs[k + 1].opname == "RETURN_VALUE")
+            if not implicit:
+                return False
+        return True
+
+    def is_compiler_generated_return(self, instr_index: int) -> bool:
+        """
+        Determine whether the RETURN at the given instruction index is the implicit compiler-inserted `return None`.
+
+        Performs conservative checks: the instruction must be effectively the final unbranched exit, must not reside inside user-level control-flow blocks (e.g., `if`, `for`, `while`, `try`, `except`, `finally`, `with`), and — when available — must not lie inside an exception-table protected range (Python 3.11+). These checks aim to distinguish a compiler-generated trailing `return None` from an explicit return written in source.
+
+        Parameters:
+            instr_index (int): Index into `self.instructions` identifying the RETURN instruction to evaluate.
+
+        Returns:
+            `true` if the RETURN is likely the compiler-inserted implicit `return None`, `false` otherwise.
+        """
+        instr = self.instructions[instr_index]
+        # Save current state for lookahead
+        old_pc = self.pc
+        self.pc = instr_index + 1
+        effectively_last = self.is_effectively_last()
+        self.pc = old_pc
+
+        # Robust check for Python 3.11+: if the return is within a protected
+        # range in the exception table, it's explicit. Compiler-generated
+        # returns for with/try blocks are always outside the protected range.
+        entries = self._exception_entries()
+        if entries and any(e.start <= instr.offset < e.end for e in entries):
+            return False
+
+        if not effectively_last and not (entries and self._ends_try_before_handlers(instr_index)):
+            return False
+
+        # If we're inside any user-facing control flow block, it's likely
+        # an explicit return in the source. A `try` or `with` block is still open
+        # at the implicit return that follows it (its handlers come after), but
+        # that return lies outside every protected range, which the check above
+        # established: those blocks do not make it explicit.
+        user_blocks = {"if", "else", "for", "while", "try_body", "except", "finally_body", "with", "with_body"}
+        if entries:
+            user_blocks -= {"try_body", "with", "with_body"}
+        blocks = getattr(self, "blocks", [])
+        for _, btype in blocks:
+            if btype in user_blocks:
+                return False
+
+        return True