angr 9.2.102__py3-none-manylinux2014_x86_64.whl → 9.2.103__py3-none-manylinux2014_x86_64.whl

angr/analyses/decompiler/structuring/phoenix.py

@@ -1,5 +1,6 @@
 # pylint:disable=line-too-long,import-outside-toplevel,import-error,multiple-statements,too-many-boolean-expressions
-from typing import List, Dict, Tuple, Union, Set, Any, DefaultDict, Optional, OrderedDict as ODict, TYPE_CHECKING
+from typing import Any, DefaultDict, Optional, TYPE_CHECKING
+from collections import OrderedDict as ODict
 from collections import defaultdict, OrderedDict
 from enum import Enum
 import logging
@@ -80,7 +81,7 @@ class PhoenixStructurer(StructurerBase):
         parent_map=None,
         condition_processor=None,
         func: Optional["Function"] = None,
-        case_entry_to_switch_head: Optional[Dict[int, int]] = None,
+        case_entry_to_switch_head: dict[int, int] | None = None,
         parent_region=None,
         improve_structurer=True,
         use_multistmtexprs: MultiStmtExprMode = MultiStmtExprMode.MAX_ONE_CALL,
@@ -101,14 +102,14 @@ class PhoenixStructurer(StructurerBase):
         # structuring cycles.
         # the set is populated during the analysis. _last_resort_refinement() will ensure not to remove any edges
         # who fall into these sets.
-        self.whitelist_edges: Set[Tuple[int, int]] = set()
+        self.whitelist_edges: set[tuple[int, int]] = set()
         # also whitelist certain nodes that are definitely header for switch-case constructs. they should not be merged
         # into another node before we successfully structure the entire switch-case.
-        self.switch_case_known_heads: Set[Block] = set()
+        self.switch_case_known_heads: set[Block] = set()
 
         # whitelist certain nodes that should be treated as a tail node for do-whiles. these nodes should not be
         # absorbed into other SequenceNodes
-        self.dowhile_known_tail_nodes: Set = set()
+        self.dowhile_known_tail_nodes: set = set()
 
         self._phoenix_improved = self._improve_structurer
         self._edge_virtualization_hints = []
@@ -266,7 +267,7 @@ class PhoenixStructurer(StructurerBase):
             self._rewrite_jumps_to_continues(loop_node.sequence_node)
         return matched
 
-    def _match_cyclic_while(self, node, head, graph, full_graph) -> Tuple[bool, Optional[LoopNode], Optional[BaseNode]]:
+    def _match_cyclic_while(self, node, head, graph, full_graph) -> tuple[bool, LoopNode | None, BaseNode | None]:
         succs = list(full_graph.successors(node))
         if len(succs) == 2:
             left, right = succs
@@ -406,7 +407,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _match_cyclic_while_with_single_successor(
         self, node, head, graph, full_graph
-    ) -> Tuple[bool, Optional[LoopNode], Optional[BaseNode]]:
+    ) -> tuple[bool, LoopNode | None, BaseNode | None]:
         if self._region.successors:
             return False, None, None
         if node is not head:
@@ -474,9 +475,7 @@ class PhoenixStructurer(StructurerBase):
 
         return True, loop_node, successor_node
 
-    def _match_cyclic_dowhile(
-        self, node, head, graph, full_graph
-    ) -> Tuple[bool, Optional[LoopNode], Optional[BaseNode]]:
+    def _match_cyclic_dowhile(self, node, head, graph, full_graph) -> tuple[bool, LoopNode | None, BaseNode | None]:
         preds = list(full_graph.predecessors(node))
         succs = list(full_graph.successors(node))
         if ((node is head and len(preds) >= 1) or len(preds) >= 2) and len(succs) == 1:
@@ -543,7 +542,7 @@ class PhoenixStructurer(StructurerBase):
                     return True, loop_node, succ
         return False, None, None
 
-    def _match_cyclic_natural_loop(self, node, head, graph, full_graph) -> Tuple[bool, Optional[LoopNode]]:
+    def _match_cyclic_natural_loop(self, node, head, graph, full_graph) -> tuple[bool, LoopNode | None]:
         if not (node is head or graph.in_degree[node] == 2):
             return False, None
 
@@ -609,8 +608,8 @@ class PhoenixStructurer(StructurerBase):
         is_while, result_while = self._refine_cyclic_is_while_loop(graph, fullgraph, loop_head, head_succs)
         is_dowhile, result_dowhile = self._refine_cyclic_is_dowhile_loop(graph, fullgraph, loop_head, head_succs)
 
-        continue_edges: List[Tuple[BaseNode, BaseNode]] = []
-        outgoing_edges: List = []
+        continue_edges: list[tuple[BaseNode, BaseNode]] = []
+        outgoing_edges: list = []
 
         if is_while and is_dowhile:
             # gotta pick one!
@@ -872,7 +871,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _refine_cyclic_is_while_loop(
         self, graph, fullgraph, loop_head, head_succs
-    ) -> Tuple[bool, Optional[Tuple[List, List, BaseNode, BaseNode]]]:
+    ) -> tuple[bool, tuple[list, list, BaseNode, BaseNode] | None]:
         if len(head_succs) == 2 and any(head_succ not in graph for head_succ in head_succs):
             # make sure the head_pred is not already structured
             _, _, head_block_0 = self._find_node_going_to_dst(loop_head, head_succs[0])
@@ -880,7 +879,7 @@ class PhoenixStructurer(StructurerBase):
             if head_block_0 is head_block_1 and head_block_0 is not None:
                 # there is an out-going edge from the loop head
                 # virtualize all other edges
-                continue_edges: List[Tuple[BaseNode, BaseNode]] = []
+                continue_edges: list[tuple[BaseNode, BaseNode]] = []
                 outgoing_edges = []
                 successor = next(iter(head_succ for head_succ in head_succs if head_succ not in graph))
                 for node in networkx.descendants(graph, loop_head):
@@ -897,7 +896,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _refine_cyclic_is_dowhile_loop(  # pylint:disable=unused-argument
         self, graph, fullgraph, loop_head, head_succs
-    ) -> Tuple[bool, Optional[Tuple[List, List, BaseNode, BaseNode]]]:
+    ) -> tuple[bool, tuple[list, list, BaseNode, BaseNode] | None]:
         # check if there is an out-going edge from the loop tail
         head_preds = list(fullgraph.predecessors(loop_head))
         if len(head_preds) == 1:
@@ -908,7 +907,7 @@ class PhoenixStructurer(StructurerBase):
                 _, _, src_block_0 = self._find_node_going_to_dst(head_pred, head_pred_succs[0])
                 _, _, src_block_1 = self._find_node_going_to_dst(head_pred, head_pred_succs[1])
                 if src_block_0 is src_block_1 and src_block_0 is not None:
-                    continue_edges: List[Tuple[BaseNode, BaseNode]] = []
+                    continue_edges: list[tuple[BaseNode, BaseNode]] = []
                     outgoing_edges = []
                     # there is an out-going edge from the loop tail
                     # virtualize all other edges
@@ -1047,7 +1046,7 @@ class PhoenixStructurer(StructurerBase):
 
         # make a fake jumptable
         node_default_addr = None
-        case_entries: Dict[int, Tuple[int, Optional[int]]] = {}
+        case_entries: dict[int, tuple[int, int | None]] = {}
         for _, case_value, case_target_addr, case_target_idx, _ in last_stmt.case_addrs:
             if isinstance(case_value, str):
                 if case_value == "default":
@@ -1264,7 +1263,7 @@ class PhoenixStructurer(StructurerBase):
         return True
 
     def _match_acyclic_incomplete_switch_cases(
-        self, node, graph: networkx.DiGraph, full_graph: networkx.DiGraph, jump_tables: Dict
+        self, node, graph: networkx.DiGraph, full_graph: networkx.DiGraph, jump_tables: dict
     ) -> bool:
         # sanity checks
         if node.addr not in jump_tables:
@@ -1300,14 +1299,14 @@ class PhoenixStructurer(StructurerBase):
 
     def _switch_build_cases(
         self,
-        case_and_entryaddrs: Dict[int, Union[int, Tuple[int, Optional[int]]]],
+        case_and_entryaddrs: dict[int, int | tuple[int, int | None]],
         head_node,
         node_a: BaseNode,
         node_b_addr,
         graph,
         full_graph,
-    ) -> Tuple[ODict, Any, Set[Any]]:
-        cases: ODict[Union[int, Tuple[int]], SequenceNode] = OrderedDict()
+    ) -> tuple[ODict, Any, set[Any]]:
+        cases: ODict[int | tuple[int], SequenceNode] = OrderedDict()
         to_remove = set()
 
         # it is possible that the default node gets duplicated by other analyses and creates a default node (addr.a)
@@ -1315,11 +1314,11 @@ class PhoenixStructurer(StructurerBase):
         # successor to node_a
         default_node_candidates = [nn for nn in graph.nodes if nn.addr == node_b_addr]
         if len(default_node_candidates) == 0:
-            node_default: Optional[BaseNode] = None
+            node_default: BaseNode | None = None
         elif len(default_node_candidates) == 1:
-            node_default: Optional[BaseNode] = default_node_candidates[0]
+            node_default: BaseNode | None = default_node_candidates[0]
         else:
-            node_default: Optional[BaseNode] = next(
+            node_default: BaseNode | None = next(
                 iter(nn for nn in default_node_candidates if graph.has_edge(head_node, nn)), None
             )
 
@@ -1331,8 +1330,8 @@ class PhoenixStructurer(StructurerBase):
             node_default = new_node
 
         # entry_addrs_set = set(jumptable_entries)
-        converted_nodes: Dict[Tuple[int, Optional[int]], Any] = {}
-        entry_addr_to_ids: DefaultDict[Tuple[int, Optional[int]], Set[int]] = defaultdict(set)
+        converted_nodes: dict[tuple[int, int | None], Any] = {}
+        entry_addr_to_ids: DefaultDict[tuple[int, int | None], set[int]] = defaultdict(set)
 
         # the default node might get duplicated (e.g., by EagerReturns). we detect if a duplicate of the default node
         # (node b) is a successor node of node a. we only skip those entries going to the default node if no duplicate
@@ -1420,7 +1419,7 @@ class PhoenixStructurer(StructurerBase):
         node_default_addr: int,
         node_default,
         addr,
-        to_remove: Set,
+        to_remove: set,
         graph: networkx.DiGraph,
         full_graph: networkx.DiGraph,
         node_a=None,
@@ -1952,7 +1951,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _match_acyclic_short_circuit_conditions_type_a(  # pylint:disable=unused-argument
         self, graph, full_graph, start_node
-    ) -> Optional[Tuple]:
+    ) -> tuple | None:
         #   if (a) goto right
         #   else if (b) goto right
         #   else goto other_succ
@@ -1990,7 +1989,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _match_acyclic_short_circuit_conditions_type_b(  # pylint:disable=unused-argument
         self, graph, full_graph, start_node
-    ) -> Optional[Tuple]:
+    ) -> tuple | None:
         #   if (a) goto left
         # right:
         #   else if (b) goto left
@@ -2032,7 +2031,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _match_acyclic_short_circuit_conditions_type_c(  # pylint:disable=unused-argument
         self, graph, full_graph, start_node
-    ) -> Optional[Tuple]:
+    ) -> tuple | None:
         #   if (a) goto successor
         #   else if (b) goto successor
         # right:
@@ -2070,7 +2069,7 @@ class PhoenixStructurer(StructurerBase):
 
     def _match_acyclic_short_circuit_conditions_type_d(  # pylint:disable=unused-argument
         self, graph, full_graph, start_node
-    ) -> Optional[Tuple]:
+    ) -> tuple | None:
         #   if (a) goto else_node
         # left:
         #   else if (b) goto else_node
@@ -2107,7 +2106,7 @@ class PhoenixStructurer(StructurerBase):
                             return left, edge_cond_left, right, edge_cond_left_right, else_node
         return None
 
-    def _last_resort_refinement(self, head, graph: networkx.DiGraph, full_graph: Optional[networkx.DiGraph]) -> bool:
+    def _last_resort_refinement(self, head, graph: networkx.DiGraph, full_graph: networkx.DiGraph | None) -> bool:
         if self._phoenix_improved:
             while self._edge_virtualization_hints:
                 src, dst = self._edge_virtualization_hints.pop(0)
@@ -2228,7 +2227,7 @@ class PhoenixStructurer(StructurerBase):
         if remove_src_last_stmt:
             remove_last_statement(src)
 
-    def _should_use_multistmtexprs(self, node: Union[Block, BaseNode]) -> bool:
+    def _should_use_multistmtexprs(self, node: Block | BaseNode) -> bool:
         if self._use_multistmtexprs == MultiStmtExprMode.NEVER:
             return False
         if self._use_multistmtexprs == MultiStmtExprMode.ALWAYS:
@@ -2244,10 +2243,10 @@ class PhoenixStructurer(StructurerBase):
     @staticmethod
     def _find_node_going_to_dst(
         node: SequenceNode,
-        dst: Union[Block, BaseNode],
+        dst: Block | BaseNode,
         last=True,
         condjump_only=False,
-    ) -> Tuple[Optional[int], Optional[BaseNode], Optional[Block]]:
+    ) -> tuple[int | None, BaseNode | None, Block | None]:
         """
 
         :param node:
@@ -2335,7 +2334,7 @@ class PhoenixStructurer(StructurerBase):
             update_seqnode_in_place=False,
             force_forward_scan=True,
         )
-        walker.parent_and_block: List[Tuple[int, Any, Union[Block, MultiNode]]] = []
+        walker.parent_and_block: list[tuple[int, Any, Block | MultiNode]] = []
         walker.block_id = -1
         walker.walk(node)
         if not walker.parent_and_block:
@@ -2385,7 +2384,7 @@ class PhoenixStructurer(StructurerBase):
                     graph.add_edge(case_node, succs[0])
 
     @staticmethod
-    def _count_statements(node: Union[BaseNode, Block]) -> int:
+    def _count_statements(node: BaseNode | Block) -> int:
         if isinstance(node, Block):
             return sum(1 for stmt in node.statements if not isinstance(stmt, Label))
         elif isinstance(node, MultiNode):
@@ -2395,19 +2394,19 @@ class PhoenixStructurer(StructurerBase):
         return 1
 
     @staticmethod
-    def _is_single_statement_block(node: Union[BaseNode, Block]) -> bool:
+    def _is_single_statement_block(node: BaseNode | Block) -> bool:
         if isinstance(node, (Block, MultiNode, SequenceNode)):
             return PhoenixStructurer._count_statements(node) == 1
         return False
 
     @staticmethod
-    def _is_sequential_statement_block(node: Union[BaseNode, Block]) -> bool:
+    def _is_sequential_statement_block(node: BaseNode | Block) -> bool:
         """
         Examine if the node can be converted into a MultiStatementExpression object. The conversion fails if there are
         any conditional statements or goto statements before the very last statement of the node.
         """
 
-        def _is_sequential_statement_list(stmts: List[Statement]) -> bool:
+        def _is_sequential_statement_list(stmts: list[Statement]) -> bool:
             if not stmts:
                 return True
             for stmt in stmts[:-1]:
@@ -2421,7 +2420,7 @@ class PhoenixStructurer(StructurerBase):
                     return False
             return True
 
-        def _to_statement_list(node: Union[Block, MultiNode, SequenceNode]) -> List[Statement]:
+        def _to_statement_list(node: Block | MultiNode | SequenceNode) -> list[Statement]:
             if isinstance(node, Block):
                 return node.statements
             if isinstance(node, MultiNode):
@@ -2444,7 +2443,7 @@ class PhoenixStructurer(StructurerBase):
         return _is_sequential_statement_list(stmt_list)
 
     @staticmethod
-    def _build_multistatementexpr_statements(block) -> Optional[List[Statement]]:
+    def _build_multistatementexpr_statements(block) -> list[Statement] | None:
         stmts = []
         if isinstance(block, (SequenceNode, MultiNode)):
             for b in block.nodes:
@@ -2474,7 +2473,7 @@ class PhoenixStructurer(StructurerBase):
                 graph.remove_edge(src, succ)
 
     @staticmethod
-    def _remove_first_statement_if_jump(node: Union[BaseNode, Block]) -> Optional[Union[Jump, ConditionalJump]]:
+    def _remove_first_statement_if_jump(node: BaseNode | Block) -> Jump | ConditionalJump | None:
         if isinstance(node, Block):
             if node.statements:
                 idx = 0
@@ -2503,7 +2502,7 @@ class PhoenixStructurer(StructurerBase):
         return None
 
     @staticmethod
-    def _chick_order_edges(edges: List, node_seq: Dict[Any, int]) -> List:
+    def _chick_order_edges(edges: list, node_seq: dict[Any, int]) -> list:
         graph = networkx.DiGraph()
         graph.add_edges_from(edges)
 
@@ -2520,7 +2519,7 @@ class PhoenixStructurer(StructurerBase):
         return list(sorted(edges, key=_sort_edge, reverse=True))
 
     @staticmethod
-    def _replace_node_in_edge_list(edge_list: List[Tuple], old_node, new_node) -> None:
+    def _replace_node_in_edge_list(edge_list: list[tuple], old_node, new_node) -> None:
         for idx in range(len(edge_list)):  # pylint:disable=consider-using-enumerate
             edge = edge_list[idx]
             src, dst = edge

angr/analyses/decompiler/structuring/recursive_structurer.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import Optional, Type, Dict, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 import logging
 
 import networkx
@@ -33,7 +33,7 @@ class RecursiveStructurer(Analysis):
         region,
         cond_proc=None,
         func: Optional["Function"] = None,
-        structurer_cls: Optional[Type] = None,
+        structurer_cls: type | None = None,
         improve_structurer=True,
         **kwargs,
     ):
@@ -51,7 +51,7 @@ class RecursiveStructurer(Analysis):
 
     def _analyze(self):
         region = self._region.recursive_copy()
-        self._case_entry_to_switch_head: Dict[int, int] = self._get_switch_case_entries()
+        self._case_entry_to_switch_head: dict[int, int] = self._get_switch_case_entries()
         self.result_incomplete = False
 
         # visit the region in post-order DFS
@@ -149,7 +149,7 @@ class RecursiveStructurer(Analysis):
     def _replace_region_with_region(parent_region, sub_region, new_region):
         parent_region.replace_region_with_region(sub_region, new_region)
 
-    def _get_switch_case_entries(self) -> Dict[int, int]:
+    def _get_switch_case_entries(self) -> dict[int, int]:
         if self.function is None:
             return {}
 

angr/analyses/decompiler/structuring/structurer_base.py

@@ -1,5 +1,6 @@
 # pylint:disable=unused-argument
-from typing import Optional, Dict, Set, List, Any, Union, Tuple, OrderedDict as ODict, TYPE_CHECKING
+from typing import Optional, Any, TYPE_CHECKING
+from collections import OrderedDict as ODict
 from collections import defaultdict, OrderedDict
 import logging
 
@@ -50,7 +51,7 @@ class StructurerBase(Analysis):
         parent_map=None,
         condition_processor=None,
         func: Optional["Function"] = None,
-        case_entry_to_switch_head: Optional[Dict[int, int]] = None,
+        case_entry_to_switch_head: dict[int, int] | None = None,
         parent_region=None,
         improve_structurer=True,
         **kwargs,
@@ -251,7 +252,7 @@ class StructurerBase(Analysis):
             if len(node.nodes) > 1:
                 for i in range(len(node.nodes) - 1):
                     this_node = node.nodes[i]
-                    jump_stmt: Optional[Union[ailment.Stmt.Jump, ailment.Stmt.ConditionalJump]] = None
+                    jump_stmt: ailment.Stmt.Jump | ailment.Stmt.ConditionalJump | None = None
                     if (
                         isinstance(this_node, ailment.Block)
                         and this_node.statements
@@ -313,7 +314,7 @@ class StructurerBase(Analysis):
             if len(node.nodes) > 1:
                 for i in range(len(node.nodes) - 1):
                     this_node = node.nodes[i]
-                    jump_stmt: Optional[Union[ailment.Stmt.Jump, ailment.Stmt.ConditionalJump]] = None
+                    jump_stmt: ailment.Stmt.Jump | ailment.Stmt.ConditionalJump | None = None
                     if (
                         isinstance(this_node, ailment.Block)
                         and this_node.statements
@@ -387,7 +388,7 @@ class StructurerBase(Analysis):
                 return
 
             # stores all nodes that will replace the current AIL Block node
-            new_nodes: List = []
+            new_nodes: list = []
             last_nonjump_stmt_idx = 0
 
             # find all jump and indirect jump statements
@@ -466,7 +467,7 @@ class StructurerBase(Analysis):
         walker = SequenceWalker(handlers=handlers)
         walker.walk(loop_node)
 
-    def _rewrite_jumps_to_continues(self, loop_seq: SequenceNode, loop_node: Optional[LoopNode] = None):
+    def _rewrite_jumps_to_continues(self, loop_seq: SequenceNode, loop_node: LoopNode | None = None):
         continue_node_addr = loop_seq.addr
         # exception: do-while with a multi-statement condition
         if (
@@ -740,12 +741,12 @@ class StructurerBase(Analysis):
     #
 
     def _reorganize_switch_cases(
-        self, cases: ODict[Union[int, Tuple[int, ...]], SequenceNode]
-    ) -> ODict[Union[int, Tuple[int, ...]], SequenceNode]:
+        self, cases: ODict[int | tuple[int, ...], SequenceNode]
+    ) -> ODict[int | tuple[int, ...], SequenceNode]:
         new_cases = OrderedDict()
 
         caseid2gotoaddrs = {}
-        addr2caseids: Dict[int, List[int, Tuple[int, ...]]] = defaultdict(list)
+        addr2caseids: dict[int, list[int, tuple[int, ...]]] = defaultdict(list)
 
         # collect goto locations
         for idx, case_node in cases.items():
@@ -814,8 +815,8 @@ class StructurerBase(Analysis):
 
     @staticmethod
     def _remove_last_statement_if_jump(
-        node: Union[BaseNode, ailment.Block]
-    ) -> Optional[Union[ailment.Stmt.Jump, ailment.Stmt.ConditionalJump]]:
+        node: BaseNode | ailment.Block,
+    ) -> ailment.Stmt.Jump | ailment.Stmt.ConditionalJump | None:
         try:
             last_stmts = ConditionProcessor.get_last_statements(node)
         except EmptyBlockNotice:
@@ -878,7 +879,7 @@ class StructurerBase(Analysis):
             else:
                 return SequenceNode(addr, nodes=[node_0, node_1])
 
-    def _update_new_sequences(self, removed_sequences: Set[SequenceNode], replaced_sequences: Dict[SequenceNode, Any]):
+    def _update_new_sequences(self, removed_sequences: set[SequenceNode], replaced_sequences: dict[SequenceNode, Any]):
         new_sequences = []
         for new_seq_ in self._new_sequences:
             if new_seq_ not in removed_sequences:
@@ -917,8 +918,8 @@ class StructurerBase(Analysis):
     @staticmethod
     def replace_node_in_node(
         parent_node: BaseNode,
-        old_node: Union[BaseNode, ailment.Block],
-        new_node: Union[BaseNode, ailment.Block],
+        old_node: BaseNode | ailment.Block,
+        new_node: BaseNode | ailment.Block,
     ) -> None:
         if isinstance(parent_node, SequenceNode):
             for i in range(len(parent_node.nodes)):  # pylint:disable=consider-using-enumerate
@@ -941,7 +942,7 @@ class StructurerBase(Analysis):
             raise TypeError(f"Unsupported node type {type(parent_node)}")
 
     @staticmethod
-    def is_a_jump_target(stmt: Union[ailment.Stmt.ConditionalJump, ailment.Stmt.Jump], addr: int) -> bool:
+    def is_a_jump_target(stmt: ailment.Stmt.ConditionalJump | ailment.Stmt.Jump, addr: int) -> bool:
         if isinstance(stmt, ailment.Stmt.ConditionalJump):
             if isinstance(stmt.true_target, ailment.Expr.Const) and stmt.true_target.value == addr:
                 return True

angr/analyses/decompiler/structuring/structurer_nodes.py

@@ -1,5 +1,6 @@
 # pylint:disable=missing-class-docstring
-from typing import List, Tuple, Any, Optional, Union, OrderedDict as ODict
+from typing import Any
+from collections import OrderedDict as ODict
 
 import claripy
 import ailment
@@ -95,7 +96,7 @@ class BaseNode:
 
         return True
 
-    addr: Optional[int]
+    addr: int | None
 
     def dbg_repr(self, indent=0):
         return " " * indent + f"## dbg_repr not implemented for {type(self).__name__}"
@@ -107,7 +108,7 @@ class SequenceNode(BaseNode):
         "nodes",
     )
 
-    def __init__(self, addr: Optional[int], nodes=None):
+    def __init__(self, addr: int | None, nodes=None):
         self.addr = addr
         self.nodes = nodes if nodes is not None else []
 
@@ -237,7 +238,7 @@ class CascadingConditionNode(BaseNode):
         "else_node",
     )
 
-    def __init__(self, addr, condition_and_nodes: List[Tuple[Any, BaseNode]], else_node: BaseNode = None):
+    def __init__(self, addr, condition_and_nodes: list[tuple[Any, BaseNode]], else_node: BaseNode = None):
         self.addr = addr
         self.condition_and_nodes = condition_and_nodes
         self.else_node = else_node
@@ -357,9 +358,9 @@ class SwitchCaseNode(BaseNode):
         "addr",
     )
 
-    def __init__(self, switch_expr, cases: ODict[Union[int, Tuple[int, ...]], SequenceNode], default_node, addr=None):
+    def __init__(self, switch_expr, cases: ODict[int | tuple[int, ...], SequenceNode], default_node, addr=None):
         self.switch_expr = switch_expr
-        self.cases: ODict[Union[int, Tuple[int, ...]], SequenceNode] = cases
+        self.cases: ODict[int | tuple[int, ...], SequenceNode] = cases
         self.default_node = default_node
         self.addr = addr
 
@@ -372,10 +373,10 @@ class IncompleteSwitchCaseNode(BaseNode):
 
     __slots__ = ("addr", "head", "cases")
 
-    def __init__(self, addr, head, cases: List):
+    def __init__(self, addr, head, cases: list):
         self.addr = addr
         self.head = head
-        self.cases: List = cases
+        self.cases: list = cases
 
 
 #
@@ -395,7 +396,7 @@ class IncompleteSwitchCaseHeadStatement(ailment.statement.Statement):
         self.switch_variable = switch_variable
         # original cmp node, case value | "default", address of the case node, idx of the case node,
         # address of the next cmp node
-        self.case_addrs: List[Tuple[ailment.Block, Union[int, str], int, Optional[int], int]] = case_addrs
+        self.case_addrs: list[tuple[ailment.Block, int | str, int, int | None, int]] = case_addrs
         # a string representation of the addresses of all cases, used for hashing
         self._case_addrs_str = str(sorted([c[0].addr for c in self.case_addrs if c[0] is not None]))
 

angr/analyses/decompiler/utils.py

@@ -1,7 +1,8 @@
 # pylint:disable=wrong-import-position,broad-exception-caught,ungrouped-imports
 import pathlib
 import copy
-from typing import Optional, Tuple, Any, Union, List, Iterable
+from typing import Any, Union
+from collections.abc import Iterable
 import logging
 
 import networkx
@@ -119,7 +120,7 @@ def extract_jump_targets(stmt):
     return targets
 
 
-def switch_extract_cmp_bounds(last_stmt: ailment.Stmt.ConditionalJump) -> Optional[Tuple[Any, int, int]]:
+def switch_extract_cmp_bounds(last_stmt: ailment.Stmt.ConditionalJump) -> tuple[Any, int, int] | None:
     """
     Check the last statement of the switch-case header node, and extract lower+upper bounds for the comparison.
 
@@ -161,7 +162,7 @@ def get_ast_subexprs(claripy_ast):
             yield ast
 
 
-def insert_node(parent, insert_location: str, node, node_idx: Optional[Union[int, Tuple[int]]], label=None):
+def insert_node(parent, insert_location: str, node, node_idx: int | tuple[int] | None, label=None):
     if insert_location not in {"before", "after"}:
         raise ValueError('"insert_location" must be either "before" or "after"')
 
@@ -336,7 +337,7 @@ def has_nonlabel_statements(block: ailment.Block) -> bool:
     return block.statements and any(not isinstance(stmt, ailment.Stmt.Label) for stmt in block.statements)
 
 
-def first_nonlabel_statement(block: Union[ailment.Block, "MultiNode"]) -> Optional[ailment.Stmt.Statement]:
+def first_nonlabel_statement(block: Union[ailment.Block, "MultiNode"]) -> ailment.Stmt.Statement | None:
     if isinstance(block, MultiNode):
         for n in block.nodes:
             stmt = first_nonlabel_statement(n)
@@ -350,14 +351,14 @@ def first_nonlabel_statement(block: Union[ailment.Block, "MultiNode"]) -> Option
     return None
 
 
-def last_nonlabel_statement(block: ailment.Block) -> Optional[ailment.Stmt.Statement]:
+def last_nonlabel_statement(block: ailment.Block) -> ailment.Stmt.Statement | None:
     for stmt in reversed(block.statements):
         if not isinstance(stmt, ailment.Stmt.Label):
             return stmt
     return None
 
 
-def first_nonlabel_node(seq: "SequenceNode") -> Optional[Union["BaseNode", ailment.Block]]:
+def first_nonlabel_node(seq: "SequenceNode") -> Union["BaseNode", ailment.Block] | None:
     for node in seq.nodes:
         if isinstance(node, CodeNode):
             inner_node = node.node
@@ -421,7 +422,7 @@ def structured_node_is_simple_return(node: Union["SequenceNode", "MultiNode"], g
     Returns true on any block ending in linear statements and a return.
     """
 
-    def _flatten_structured_node(packed_node: Union["SequenceNode", "MultiNode"]) -> List[ailment.Block]:
+    def _flatten_structured_node(packed_node: Union["SequenceNode", "MultiNode"]) -> list[ailment.Block]:
         if not packed_node or not packed_node.nodes:
             return []
 
@@ -477,8 +478,8 @@ def peephole_optimize_exprs(block, expr_opts):
         v = False
 
     def _handle_expr(
-        expr_idx: int, expr: ailment.Expr.Expression, stmt_idx: int, stmt: Optional[ailment.Stmt.Statement], block
-    ) -> Optional[ailment.Expr.Expression]:
+        expr_idx: int, expr: ailment.Expr.Expression, stmt_idx: int, stmt: ailment.Stmt.Statement | None, block
+    ) -> ailment.Expr.Expression | None:
         old_expr = expr
 
         redo = True
@@ -510,8 +511,8 @@ def peephole_optimize_exprs(block, expr_opts):
 
 def peephole_optimize_expr(expr, expr_opts):
     def _handle_expr(
-        expr_idx: int, expr: ailment.Expr.Expression, stmt_idx: int, stmt: Optional[ailment.Stmt.Statement], block
-    ) -> Optional[ailment.Expr.Expression]:
+        expr_idx: int, expr: ailment.Expr.Expression, stmt_idx: int, stmt: ailment.Stmt.Statement | None, block
+    ) -> ailment.Expr.Expression | None:
         old_expr = expr
 
         redo = True
@@ -595,7 +596,7 @@ def peephole_optimize_stmts(block, stmt_opts):
     return statements, any_update
 
 
-def match_stmt_classes(all_stmts: List, idx: int, stmt_class_seq: Iterable[type]) -> bool:
+def match_stmt_classes(all_stmts: list, idx: int, stmt_class_seq: Iterable[type]) -> bool:
     for i, cls in enumerate(stmt_class_seq):
         if idx + i >= len(all_stmts):
             return False
@@ -639,7 +640,7 @@ def peephole_optimize_multistmts(block, stmt_opts):
     return statements, any_update
 
 
-def decompile_functions(path, functions=None, structurer=None, catch_errors=False) -> Optional[str]:
+def decompile_functions(path, functions=None, structurer=None, catch_errors=False) -> str | None:
     """
     Decompile a binary into a set of functions.
 
@@ -663,7 +664,7 @@ def decompile_functions(path, functions=None, structurer=None, catch_errors=Fals
         functions = list(sorted(cfg.kb.functions))
 
     # normalize the functions that could be ints as names
-    normalized_functions: List[Union[int, str]] = []
+    normalized_functions: list[int | str] = []
     for func in functions:
         try:
             if isinstance(func, str):
@@ -742,7 +743,7 @@ def find_block_by_addr(graph: networkx.DiGraph, addr: int):
     raise KeyError("The block is not in the graph!")
 
 
-def sequence_to_blocks(seq: "BaseNode") -> List[ailment.Block]:
+def sequence_to_blocks(seq: "BaseNode") -> list[ailment.Block]:
     """
     Converts a sequence node (BaseNode) to a list of ailment blocks contained in it and all its children.
     """
@@ -753,7 +754,7 @@ def sequence_to_blocks(seq: "BaseNode") -> List[ailment.Block]:
 
 def sequence_to_statements(
     seq: "BaseNode", exclude=(ailment.statement.Jump, ailment.statement.Jump)
-) -> List[ailment.statement.Statement]:
+) -> list[ailment.statement.Statement]:
     """
     Converts a sequence node (BaseNode) to a list of ailment Statements contained in it and all its children.
     May exclude certain types of statements.