Allow fusing TryBegin with an unknown stack size when converting from CFG to bytecode (#120)

* cfg: forget about seen TryEnd if we encounter an already seen TryEnd

* cfg: ensure we remove dead TryEnd when fusing TryBegin/TryEnd pairs when going from CFG to bytecode

* doc: update release notes

Author: MatthieuDartiailh

doc/changelog.rst

@@ -1,6 +1,16 @@
 ChangeLog
 =========
 
+unreleased: Version 0.14.2
+--------------------------
+
+Bugfixes:
+
+- allow to convert a CFG, for which stack sizes have not been computed, to Bytecode
+  even in the presence of mergeable TryBegin/TryEnd  PR #120
+- remove spurious TryEnd leftover when going from CFG to Bytecode  PR #120
+
+
 2023-04-04: Version 0.14.1
 --------------------------
 

src/bytecode/cfg.py

@@ -819,8 +819,8 @@ def from_bytecode(bytecode: _bytecode.Bytecode) -> "ControlFlowGraph":
             # - if the current instruction is a TryEnd and if the last instruction
             #   is final in which case we insert the TryEnd in the old block.
             # - if we have a currently active TryBegin for which we may need to
-            #   create a TryEnd in the previous and a new TryBegin in the new one
-            #   because the blocks are not connected.
+            #   create a TryEnd in the previous block and a new TryBegin in the
+            #   new one because the blocks are not connected.
             if old_block is not None:
                 temp = try_begin_inserted_in_block
                 try_begin_inserted_in_block = False
@@ -981,23 +981,26 @@ def to_bytecode(self) -> _bytecode.Bytecode:
 
                         # If the TryBegin share the target and push_lasti of the
                         # entry of an adjacent TryEnd, omit the new TryBegin that
-                        # was inserted to allow analysis of the CFG
+                        # was inserted to allow analysis of the CFG and remove
+                        # the already inserted TryEnd.
                         if last_try_end is not None:
                             cfg_te, byt_te = last_try_end
                             entry = cfg_te.entry
                             if (
                                 entry.target is instr.target
                                 and entry.push_lasti == instr.push_lasti
                             ):
-                                # If the exception table is in a dead code portion
-                                # simply use a size of zero
+                                # If we did not yet compute the required stack depth
+                                # keep the value as UNSET
                                 if entry.stack_depth is UNSET:
-                                    byt_te.entry.stack_depth = 0
+                                    assert instr.stack_depth is UNSET
+                                    byt_te.entry.stack_depth = UNSET
                                 else:
                                     byt_te.entry.stack_depth = min(
                                         entry.stack_depth, instr.stack_depth
                                     )
                                 try_begins[instr] = byt_te.entry
+                                instructions.remove(byt_te)
                                 continue
                         assert isinstance(new, TryBegin)
                         try_begins[instr] = new