angr 9.2.101__py3-none-win_amd64.whl → 9.2.103__py3-none-win_amd64.whl

angr/analyses/decompiler/peephole_optimizations/eager_eval.py

@@ -216,7 +216,7 @@ class EagerEvaluation(PeepholeOptimizationExprBase):
 
     @staticmethod
     def _optimize_convert(expr: Convert):
-        if isinstance(expr.operand, Const):
+        if isinstance(expr.operand, Const) and expr.from_type == Convert.TYPE_INT and expr.to_type == Convert.TYPE_INT:
             if expr.from_bits > expr.to_bits:
                 # truncation
                 mask = (1 << expr.to_bits) - 1

angr/analyses/decompiler/peephole_optimizations/inlined_strcpy.py

@@ -1,5 +1,4 @@
 # pylint:disable=arguments-differ
-from typing import Tuple, Optional, Dict, List
 import string
 
 from archinfo import Endness
@@ -25,7 +24,7 @@ class InlinedStrcpy(PeepholeOptimizationStmtBase):
     stmt_classes = (Store,)
 
     def optimize(self, stmt: Store, stmt_idx: int = None, block=None, **kwargs):
-        if isinstance(stmt.data, Const):
+        if isinstance(stmt.data, Const) and isinstance(stmt.data.value, int):
             r, s = self.is_integer_likely_a_string(stmt.data.value, stmt.data.size, stmt.endness)
             if r:
                 # replace it with a call to strncpy
@@ -43,9 +42,7 @@ class InlinedStrcpy(PeepholeOptimizationStmtBase):
 
             # scan forward in the current block to find all consecutive constant stores
             if block is not None and stmt_idx is not None:
-                all_constant_stores: Dict[int, Tuple[int, Optional[Const]]] = self.collect_constant_stores(
-                    block, stmt_idx
-                )
+                all_constant_stores: dict[int, tuple[int, Const | None]] = self.collect_constant_stores(block, stmt_idx)
                 if all_constant_stores:
                     offsets = sorted(all_constant_stores.keys())
                     next_offset = min(offsets)
@@ -87,7 +84,7 @@ class InlinedStrcpy(PeepholeOptimizationStmtBase):
         return None
 
     @staticmethod
-    def stride_to_int(stride: List[Tuple[int, int, Const]]) -> Tuple[int, int]:
+    def stride_to_int(stride: list[tuple[int, int, Const]]) -> tuple[int, int]:
         stride = sorted(stride, key=lambda x: x[0])
         n = 0
         size = 0
@@ -98,7 +95,7 @@ class InlinedStrcpy(PeepholeOptimizationStmtBase):
         return n, size
 
     @staticmethod
-    def collect_constant_stores(block, starting_stmt_idx: int) -> Dict[int, Tuple[int, Optional[Const]]]:
+    def collect_constant_stores(block, starting_stmt_idx: int) -> dict[int, tuple[int, Const | None]]:
         r = {}
         for idx, stmt in enumerate(block.statements):
             if idx < starting_stmt_idx:
@@ -112,9 +109,7 @@ class InlinedStrcpy(PeepholeOptimizationStmtBase):
         return r
 
     @staticmethod
-    def is_integer_likely_a_string(
-        v: int, size: int, endness: Endness, min_length: int = 4
-    ) -> Tuple[bool, Optional[str]]:
+    def is_integer_likely_a_string(v: int, size: int, endness: Endness, min_length: int = 4) -> tuple[bool, str | None]:
         # we need at least four bytes of printable characters
 
         chars = []

angr/analyses/decompiler/peephole_optimizations/inlined_strcpy_consolidation.py

@@ -1,5 +1,4 @@
 # pylint:disable=arguments-differ
-from typing import List, Tuple, Optional
 
 from ailment.expression import Expression, BinaryOp, Const, Register, StackBaseOffset
 from ailment.statement import Call, Store
@@ -18,7 +17,7 @@ class InlinedStrcpyConsolidation(PeepholeOptimizationMultiStmtBase):
     NAME = "Consolidate multiple inlined strcpy calls"
     stmt_classes = ((Call, Call), (Call, Store))
 
-    def optimize(self, stmts: List[Call], **kwargs):
+    def optimize(self, stmts: list[Call], **kwargs):
         last_stmt, stmt = stmts
         if InlinedStrcpyConsolidation._is_inlined_strcpy(last_stmt):
             s_last: bytes = self.kb.custom_strings[last_stmt.args[1].value]
@@ -79,7 +78,7 @@ class InlinedStrcpyConsolidation(PeepholeOptimizationMultiStmtBase):
         return False
 
     @staticmethod
-    def _parse_addr(addr: Expression) -> Tuple[Expression, int]:
+    def _parse_addr(addr: Expression) -> tuple[Expression, int]:
         if isinstance(addr, Register):
             return addr, 0
         if isinstance(addr, StackBaseOffset):
@@ -95,7 +94,7 @@ class InlinedStrcpyConsolidation(PeepholeOptimizationMultiStmtBase):
         return addr, 0
 
     @staticmethod
-    def _get_delta(addr_0: Expression, addr_1: Expression) -> Optional[int]:
+    def _get_delta(addr_0: Expression, addr_1: Expression) -> int | None:
         base_0, offset_0 = InlinedStrcpyConsolidation._parse_addr(addr_0)
         base_1, offset_1 = InlinedStrcpyConsolidation._parse_addr(addr_1)
         if base_0.likes(base_1):

angr/analyses/decompiler/peephole_optimizations/inlined_wstrcpy.py

@@ -1,5 +1,4 @@
 # pylint:disable=arguments-differ
-from typing import Tuple, Optional, Dict, List
 import string
 
 from archinfo import Endness
@@ -25,7 +24,7 @@ class InlinedWstrcpy(PeepholeOptimizationStmtBase):
     stmt_classes = (Store,)
 
     def optimize(self, stmt: Store, stmt_idx: int = None, block=None, **kwargs):
-        if isinstance(stmt.data, Const):
+        if isinstance(stmt.data, Const) and isinstance(stmt.data.value, int):
             r, s = self.is_integer_likely_a_wide_string(stmt.data.value, stmt.data.size, stmt.endness)
             if r:
                 # replace it with a call to strncpy
@@ -43,9 +42,7 @@ class InlinedWstrcpy(PeepholeOptimizationStmtBase):
 
             # scan forward in the current block to find all consecutive constant stores
             if block is not None and stmt_idx is not None:
-                all_constant_stores: Dict[int, Tuple[int, Optional[Const]]] = self.collect_constant_stores(
-                    block, stmt_idx
-                )
+                all_constant_stores: dict[int, tuple[int, Const | None]] = self.collect_constant_stores(block, stmt_idx)
                 if all_constant_stores:
                     offsets = sorted(all_constant_stores.keys())
                     next_offset = min(offsets)
@@ -87,7 +84,7 @@ class InlinedWstrcpy(PeepholeOptimizationStmtBase):
         return None
 
     @staticmethod
-    def stride_to_int(stride: List[Tuple[int, int, Const]]) -> Tuple[int, int]:
+    def stride_to_int(stride: list[tuple[int, int, Const]]) -> tuple[int, int]:
         stride = sorted(stride, key=lambda x: x[0])
         n = 0
         size = 0
@@ -98,7 +95,7 @@ class InlinedWstrcpy(PeepholeOptimizationStmtBase):
         return n, size
 
     @staticmethod
-    def collect_constant_stores(block, starting_stmt_idx: int) -> Dict[int, Tuple[int, Optional[Const]]]:
+    def collect_constant_stores(block, starting_stmt_idx: int) -> dict[int, tuple[int, Const | None]]:
         r = {}
         for idx, stmt in enumerate(block.statements):
             if idx < starting_stmt_idx:
@@ -112,17 +109,17 @@ class InlinedWstrcpy(PeepholeOptimizationStmtBase):
         return r
 
     @staticmethod
-    def even_offsets_are_zero(lst: List[str]) -> bool:
+    def even_offsets_are_zero(lst: list[str]) -> bool:
         return all(ch == "\x00" for i, ch in enumerate(lst) if i % 2 == 0)
 
     @staticmethod
-    def odd_offsets_are_zero(lst: List[str]) -> bool:
+    def odd_offsets_are_zero(lst: list[str]) -> bool:
         return all(ch == "\x00" for i, ch in enumerate(lst) if i % 2 == 1)
 
     @staticmethod
     def is_integer_likely_a_wide_string(
         v: int, size: int, endness: Endness, min_length: int = 4
-    ) -> Tuple[bool, Optional[str]]:
+    ) -> tuple[bool, str | None]:
         # we need at least four bytes of printable characters
 
         chars = []

angr/analyses/decompiler/peephole_optimizations/rewrite_bit_extractions.py

@@ -1,5 +1,4 @@
 # pylint:disable=too-many-boolean-expressions
-from typing import Optional, Dict, Tuple
 from ailment.expression import Expression, BinaryOp, Const, Convert, ITE
 
 from .base import PeepholeOptimizationExprBase
@@ -36,7 +35,7 @@ class RewriteBitExtractions(PeepholeOptimizationExprBase):
 
         return None
 
-    def _extract_bitoffset_to_expr_mapping(self, expr: BinaryOp) -> Optional[Dict[int, Expression]]:
+    def _extract_bitoffset_to_expr_mapping(self, expr: BinaryOp) -> dict[int, Expression] | None:
         d = {}
         if isinstance(expr, BinaryOp) and expr.op == "Or":
             for arg in expr.operands:
@@ -61,7 +60,7 @@ class RewriteBitExtractions(PeepholeOptimizationExprBase):
         return d
 
     @staticmethod
-    def _get_setbit(expr: Expression) -> Optional[Tuple[int, Expression]]:
+    def _get_setbit(expr: Expression) -> tuple[int, Expression] | None:
         """
         Test if expr is a single-bit expression, and if it is, return the bit offset that it sets and the inner
         expression that sets the bit.

angr/analyses/decompiler/peephole_optimizations/sar_to_signed_div.py

@@ -1,4 +1,3 @@
-from typing import Optional, Tuple
 from ailment.expression import Convert, BinaryOp, Const, ITE, Expression, Register
 
 from .base import PeepholeOptimizationExprBase
@@ -75,7 +74,7 @@ class SarToSignedDiv(PeepholeOptimizationExprBase):
         return None
 
     @staticmethod
-    def _check_signedness(expr) -> Optional[Tuple[bool, int, Expression]]:
+    def _check_signedness(expr) -> tuple[bool, int, Expression] | None:
         # return a tuple of ( is_signed (False for is_unsigned), bits of the expression to test for signedness, and the
         # expression itself ).
         if isinstance(expr, BinaryOp):

angr/analyses/decompiler/peephole_optimizations/tidy_stack_addr.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from ailment.expression import UnaryOp, BinaryOp, StackBaseOffset, Const
 
@@ -30,8 +30,8 @@ class TidyStackAddr(PeepholeOptimizationExprBase):
             return None
 
         # consolidate all expressions into a list of expressions with their signs (True for +, False for -)
-        all_operands: List[Tuple[bool, "Expression"]] = []
-        stack: List[Tuple[bool, "Expression"]] = [(True, expr)]
+        all_operands: list[tuple[bool, "Expression"]] = []
+        stack: list[tuple[bool, "Expression"]] = [(True, expr)]
         stackbase_count = 0
         while stack:
             sign, item = stack.pop(0)
@@ -54,7 +54,7 @@ class TidyStackAddr(PeepholeOptimizationExprBase):
 
         # collect all constants until the next StackBaseOffset object and merge them into the prior StackBaseOffset
         # object.
-        stackbaseoffset_objs: List[Tuple[bool, StackBaseOffset]] = []
+        stackbaseoffset_objs: list[tuple[bool, StackBaseOffset]] = []
 
         # find StackBaseOffset objects and record their indices
         stackbaseoffset_indices = []

angr/analyses/decompiler/redundant_label_remover.py

@@ -1,5 +1,4 @@
 # pylint:disable=unused-argument
-from typing import Set, Optional, Tuple, Dict
 
 import ailment
 
@@ -18,12 +17,12 @@ class RedundantLabelRemover:
     anywhere (determined by jump_targets), or (b) are deemed replaceable by the first pass.
     """
 
-    def __init__(self, node, jump_targets: Set[Tuple[int, Optional[int]]]):
+    def __init__(self, node, jump_targets: set[tuple[int, int | None]]):
         self.root = node
         self._jump_targets = jump_targets
 
-        self._labels_to_remove: Set[ailment.Stmt.Label] = set()
-        self._new_jump_target: Dict[Tuple[int, Optional[int]], Tuple[int, Optional[int]]] = {}
+        self._labels_to_remove: set[ailment.Stmt.Label] = set()
+        self._new_jump_target: dict[tuple[int, int | None], tuple[int, int | None]] = {}
 
         handlers0 = {
             SequenceNode: self._handle_Sequence,
@@ -44,7 +43,7 @@ class RedundantLabelRemover:
 
     def _handle_Sequence(self, node: SequenceNode, **kwargs):
         # merge consecutive labels
-        last_label_addr: Optional[Tuple[int, Optional[int]]] = None
+        last_label_addr: tuple[int, int | None] | None = None
         for node_ in node.nodes:
             if isinstance(node_, ailment.Block):
                 if node_.statements:

angr/analyses/decompiler/region_identifier.py

@@ -1,7 +1,6 @@
 from itertools import count
 from collections import defaultdict
 import logging
-from typing import List, Optional, Union
 
 import networkx
 
@@ -59,7 +58,7 @@ class RegionIdentifier(Analysis):
 
         self.region = None
         self._start_node = None
-        self._loop_headers: Optional[List] = None
+        self._loop_headers: list | None = None
         self.regions_by_block_addrs = []
         self._largest_successor_tree_outside_loop = largest_successor_tree_outside_loop
         self._force_loop_single_exit = force_loop_single_exit
@@ -102,7 +101,7 @@ class RegionIdentifier(Analysis):
         # make regions into block address lists
         self.regions_by_block_addrs = self._make_regions_by_block_addrs()
 
-    def _make_regions_by_block_addrs(self) -> List[List[int]]:
+    def _make_regions_by_block_addrs(self) -> list[list[int]]:
         """
         Creates a list of addr lists representing each region without recursion. A single region is defined
         as a set of only blocks, no Graphs containing nested regions. The list contains the address of each
@@ -190,7 +189,7 @@ class RegionIdentifier(Analysis):
             else:
                 break
 
-    def _find_loop_headers(self, graph: networkx.DiGraph) -> List:
+    def _find_loop_headers(self, graph: networkx.DiGraph) -> list:
         heads = {t for _, t in dfs_back_edges(graph, self._start_node)}
         return GraphUtils.quasi_topological_sort_nodes(graph, heads)
 
@@ -1061,7 +1060,7 @@ class RegionIdentifier(Analysis):
         assert node_mommy not in graph
         assert node_kiddie not in graph
 
-    def _ensure_jump_at_loop_exit_ends(self, node: Union[Block, MultiNode]) -> None:
+    def _ensure_jump_at_loop_exit_ends(self, node: Block | MultiNode) -> None:
         if isinstance(node, Block):
             if not node.statements:
                 node.statements.append(

angr/analyses/decompiler/region_simplifiers/cascading_cond_transformer.py

@@ -1,5 +1,4 @@
 # pylint:disable=no-self-use,arguments-renamed,isinstance-second-argument-not-valid-type
-from typing import Optional
 
 import ailment
 import claripy
@@ -19,7 +18,7 @@ class CascadingConditionTransformer(SequenceWalker):
             ConditionNode: self._handle_Condition,
         }
         super().__init__(handlers)
-        self.cascading_if_node: Optional[CascadingConditionNode] = None
+        self.cascading_if_node: CascadingConditionNode | None = None
 
         self.walk(node)
 

angr/analyses/decompiler/region_simplifiers/expr_folding.py

@@ -1,6 +1,7 @@
 # pylint:disable=missing-class-docstring,unused-argument
 from collections import defaultdict
-from typing import Optional, Any, Dict, Set, Tuple, Iterable, Union, DefaultDict, TYPE_CHECKING
+from typing import Optional, Any, DefaultDict, TYPE_CHECKING
+from collections.abc import Iterable
 
 import ailment
 from ailment import Expression, Block, AILBlockWalker
@@ -95,7 +96,7 @@ class ConditionLocation(LocationBase):
         "case_idx",
     )
 
-    def __init__(self, cond_node_addr, case_idx: Optional[int] = None):
+    def __init__(self, cond_node_addr, case_idx: int | None = None):
         self.node_addr = cond_node_addr
         self.case_idx = case_idx
 
@@ -139,7 +140,7 @@ class MultiStatementExpressionAssignmentFinder(AILBlockWalker):
         self._stmt_handler = stmt_handler
 
     def _handle_MultiStatementExpression(
-        self, expr_idx, expr: "MultiStatementExpression", stmt_idx: int, stmt: Statement, block: Optional[Block]
+        self, expr_idx, expr: "MultiStatementExpression", stmt_idx: int, stmt: Statement, block: Block | None
     ):
         for idx, stmt_ in enumerate(expr.stmts):
             self._stmt_handler(idx, stmt_, block)
@@ -174,11 +175,11 @@ class ExpressionUseFinder(AILBlockWalker):
 
     def __init__(self):
         super().__init__()
-        self.uses: DefaultDict[SimVariable, Set[Tuple[Expression, Optional[ExpressionLocation]]]] = defaultdict(set)
+        self.uses: DefaultDict[SimVariable, set[tuple[Expression, ExpressionLocation | None]]] = defaultdict(set)
         self.has_load = False
 
     def _handle_expr(
-        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Optional[Statement], block: Optional[Block]
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
     ) -> Any:
         if isinstance(expr, ailment.Register) and expr.variable is not None:
             if not (isinstance(stmt, ailment.Stmt.Assignment) and stmt.dst is expr):
@@ -189,9 +190,7 @@ class ExpressionUseFinder(AILBlockWalker):
             return None
         return super()._handle_expr(expr_idx, expr, stmt_idx, stmt, block)
 
-    def _handle_Load(
-        self, expr_idx: int, expr: ailment.Expr.Load, stmt_idx: int, stmt: Statement, block: Optional[Block]
-    ):
+    def _handle_Load(self, expr_idx: int, expr: ailment.Expr.Load, stmt_idx: int, stmt: Statement, block: Block | None):
         self.has_load = True
         return super()._handle_Load(expr_idx, expr, stmt_idx, stmt, block)
 
@@ -213,8 +212,8 @@ class ExpressionCounter(SequenceWalker):
         # each element in the set is a tuple of (source of the assignment statement, a tuple of unified variables that
         # the current assignment depends on, StatementLocation of the assignment statement, a Boolean variable that
         # indicates if ExpressionUseFinder has succeeded or not)
-        self.assignments: DefaultDict[Any, Set[Tuple]] = defaultdict(set)
-        self.uses: Dict[SimVariable, Set[Tuple[Expression, Optional[LocationBase]]]] = {}
+        self.assignments: DefaultDict[Any, set[tuple]] = defaultdict(set)
+        self.uses: dict[SimVariable, set[tuple[Expression, LocationBase | None]]] = {}
         self._variable_manager: "VariableManagerInternal" = variable_manager
 
         super().__init__(handlers)
@@ -227,7 +226,7 @@ class ExpressionCounter(SequenceWalker):
 
         return self._variable_manager.unified_variable(v)
 
-    def _handle_Statement(self, idx: int, stmt: ailment.Stmt, node: Union[ailment.Block, LoopNode]):
+    def _handle_Statement(self, idx: int, stmt: ailment.Stmt, node: ailment.Block | LoopNode):
         if isinstance(stmt, ailment.Stmt.Assignment):
             if isinstance(stmt.dst, ailment.Expr.Register) and stmt.dst.variable is not None:
                 u = self._u(stmt.dst.variable)
@@ -331,7 +330,7 @@ class ExpressionCounter(SequenceWalker):
 
 
 class ExpressionReplacer(AILBlockWalker):
-    def __init__(self, assignments: Dict, uses: Dict, variable_manager):
+    def __init__(self, assignments: dict, uses: dict, variable_manager):
         super().__init__()
         self._assignments = assignments
         self._uses = uses
@@ -344,7 +343,7 @@ class ExpressionReplacer(AILBlockWalker):
         return self._variable_manager.unified_variable(v)
 
     def _handle_MultiStatementExpression(
-        self, expr_idx, expr: "MultiStatementExpression", stmt_idx: int, stmt: Statement, block: Optional[Block]
+        self, expr_idx, expr: "MultiStatementExpression", stmt_idx: int, stmt: Statement, block: Block | None
     ):
         changed = False
         new_statements = []
@@ -385,7 +384,7 @@ class ExpressionReplacer(AILBlockWalker):
             return expr_
         return None
 
-    def _handle_Assignment(self, stmt_idx: int, stmt: Assignment, block: Optional[Block]):
+    def _handle_Assignment(self, stmt_idx: int, stmt: Assignment, block: Block | None):
         # override the base handler and make sure we do not replace .dst with a Call expression or an ITE expression
         changed = False
 
@@ -410,7 +409,7 @@ class ExpressionReplacer(AILBlockWalker):
         return None
 
     def _handle_expr(
-        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Optional[Statement], block: Optional[Block]
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
     ) -> Any:
         if isinstance(expr, ailment.Register) and expr.variable is not None:
             unified_var = self._u(expr.variable)
@@ -421,7 +420,7 @@ class ExpressionReplacer(AILBlockWalker):
 
 
 class ExpressionFolder(SequenceWalker):
-    def __init__(self, assignments: Dict, uses: Dict, node, variable_manager):
+    def __init__(self, assignments: dict, uses: dict, node, variable_manager):
         handlers = {
             ailment.Block: self._handle_Block,
             ConditionNode: self._handle_Condition,
@@ -530,7 +529,7 @@ class StoreStatementFinder(SequenceWalker):
     This class overrides _handle_Sequence() and _handle_MultiNode() to ensure they traverse nodes from top to bottom.
     """
 
-    def __init__(self, node, intervals: Iterable[Tuple[StatementLocation, LocationBase]]):
+    def __init__(self, node, intervals: Iterable[tuple[StatementLocation, LocationBase]]):
         handlers = {
             ConditionNode: self._handle_Condition,
             CascadingConditionNode: self._handle_CascadingCondition,
@@ -540,9 +539,9 @@ class StoreStatementFinder(SequenceWalker):
 
         self._intervals = intervals
 
-        self._start_to_ends: DefaultDict[StatementLocation, Set[LocationBase]] = defaultdict(set)
-        self._end_to_starts: DefaultDict[LocationBase, Set[StatementLocation]] = defaultdict(set)
-        self.interval_to_hasstore: Dict[Tuple[StatementLocation, StatementLocation], bool] = {}
+        self._start_to_ends: DefaultDict[StatementLocation, set[LocationBase]] = defaultdict(set)
+        self._end_to_starts: DefaultDict[LocationBase, set[StatementLocation]] = defaultdict(set)
+        self.interval_to_hasstore: dict[tuple[StatementLocation, StatementLocation], bool] = {}
         for start, end in intervals:
             self._start_to_ends[start].add(end)
             self._end_to_starts[end].add(start)

angr/analyses/decompiler/region_simplifiers/goto.py

@@ -1,5 +1,4 @@
 # pylint:disable=unused-argument,arguments-differ
-from typing import Set, Union
 import logging
 
 import ailment
@@ -47,7 +46,7 @@ class GotoSimplifier(SequenceWalker):
         self.irreducible_gotos = set()
 
         super().__init__(handlers)
-        self._node_addrs: Set[int] = NodeAddressFinder(node).addrs
+        self._node_addrs: set[int] = NodeAddressFinder(node).addrs
 
         self.walk(node)
 
@@ -156,7 +155,7 @@ class GotoSimplifier(SequenceWalker):
                 self._handle_irreducible_goto(block, last_stmt, branch_target=False)
 
     def _handle_irreducible_goto(
-        self, block, goto_stmt: Union[ailment.Stmt.Jump, ailment.Stmt.ConditionalJump], branch_target=None
+        self, block, goto_stmt: ailment.Stmt.Jump | ailment.Stmt.ConditionalJump, branch_target=None
     ):
         if not self._function:
             l.debug("Unable to store a goto at %#x because simplifier is kb or functionless", block.addr)

angr/analyses/decompiler/region_simplifiers/loop.py

@@ -1,6 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
 from collections import defaultdict
-from typing import Dict, List
 
 import ailment
 
@@ -36,7 +35,7 @@ class LoopSimplifier(SequenceWalker):
 
         super().__init__(handlers)
         self.functions = functions
-        self.continue_preludes: Dict[LoopNode, List[ailment.Block]] = defaultdict(list)
+        self.continue_preludes: dict[LoopNode, list[ailment.Block]] = defaultdict(list)
         self.walk(node)
 
     @staticmethod

angr/analyses/decompiler/region_simplifiers/node_address_finder.py

@@ -1,5 +1,4 @@
 # pylint:disable=unused-argument,arguments-differ
-from typing import Set
 
 import ailment
 
@@ -16,7 +15,7 @@ class NodeAddressFinder(SequenceWalker):
             ailment.Block: self._handle_Block,
         }
         super().__init__(handlers=handlers)
-        self.addrs: Set[int] = set()
+        self.addrs: set[int] = set()
 
         self.walk(node)
 

angr/analyses/decompiler/region_simplifiers/region_simplifier.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import ailment
 
 from ..goto_manager import GotoManager
@@ -31,7 +29,7 @@ class RegionSimplifier(Analysis):
         self._simplify_switches = simplify_switches
         self._should_simplify_ifelses = simplify_ifelse
 
-        self.goto_manager: Optional[GotoManager] = None
+        self.goto_manager: GotoManager | None = None
         self.result = None
 
         self._simplify()

angr/analyses/decompiler/region_simplifiers/switch_cluster_simplifier.py

@@ -1,6 +1,6 @@
 # pylint:disable=no-self-use,arguments-renamed
 import enum
-from typing import DefaultDict, Any, List, Union, Dict, Tuple, Set, Optional
+from typing import DefaultDict, Any
 from collections import OrderedDict, defaultdict
 
 import ailment
@@ -36,7 +36,7 @@ class ConditionalRegion:
         "parent",
     )
 
-    def __init__(self, variable, op: CmpOp, value: int, node: Union[ConditionNode, ailment.Block], parent=None):
+    def __init__(self, variable, op: CmpOp, value: int, node: ConditionNode | ailment.Block, parent=None):
         self.variable = variable
         self.op = op
         self.value = value
@@ -80,8 +80,8 @@ class SwitchClusterFinder(SequenceWalker):
         }
         super().__init__(handlers)
 
-        self.var2condnodes: DefaultDict[Any, List[ConditionalRegion]] = defaultdict(list)
-        self.var2switches: DefaultDict[Any, List[SwitchCaseRegion]] = defaultdict(list)
+        self.var2condnodes: DefaultDict[Any, list[ConditionalRegion]] = defaultdict(list)
+        self.var2switches: DefaultDict[Any, list[SwitchCaseRegion]] = defaultdict(list)
 
         self.walk(node)
 
@@ -103,7 +103,7 @@ class SwitchClusterFinder(SequenceWalker):
             self.var2switches[variable].append(scr)
         return super()._handle_SwitchCase(node, parent=parent, **kwargs)
 
-    def _process_condition(self, cond: ailment.Expr.Expression, node: Union[ConditionNode, ailment.Block], parent):
+    def _process_condition(self, cond: ailment.Expr.Expression, node: ConditionNode | ailment.Block, parent):
         negated = False
         if isinstance(cond, ailment.Expr.UnaryOp) and cond.op == "Not":
             negated = True
@@ -173,7 +173,7 @@ class SwitchClusterReplacer(SequenceWalker):
         return super()._handle_Condition(node, **kwargs)
 
 
-def is_simple_jump_node(node, case_addrs, targets: Optional[Set[int]] = None) -> bool:
+def is_simple_jump_node(node, case_addrs, targets: set[int] | None = None) -> bool:
     if isinstance(node, (SequenceNode, MultiNode)):
         return all(is_simple_jump_node(nn, case_addrs) for nn in node.nodes)
     if isinstance(node, ailment.Block):
@@ -213,7 +213,7 @@ def is_simple_jump_node(node, case_addrs, targets: Optional[Set[int]] = None) ->
     return False
 
 
-def filter_cond_regions(cond_regions: List[ConditionalRegion], case_addrs: Set[int]) -> List[ConditionalRegion]:
+def filter_cond_regions(cond_regions: list[ConditionalRegion], case_addrs: set[int]) -> list[ConditionalRegion]:
     """
     Remove all conditional regions that cannot be merged into switch(es).
     """
@@ -242,8 +242,8 @@ def filter_cond_regions(cond_regions: List[ConditionalRegion], case_addrs: Set[i
 
 
 def update_switch_case_list(
-    cases: List[Tuple[Union[int, Tuple[int, ...]], SequenceNode]],
-    old_case_id: Union[int, Tuple[int, ...]],
+    cases: list[tuple[int | tuple[int, ...], SequenceNode]],
+    old_case_id: int | tuple[int, ...],
     new_case_id: int,
 ) -> None:
     """
@@ -265,7 +265,7 @@ def update_switch_case_list(
 
 
 def simplify_switch_clusters(
-    region, var2condnodes: Dict[Any, List[ConditionalRegion]], var2switches: Dict[Any, List[SwitchCaseRegion]]
+    region, var2condnodes: dict[Any, list[ConditionalRegion]], var2switches: dict[Any, list[SwitchCaseRegion]]
 ):
     """
     Identify switch clusters and simplify each of them.
@@ -284,7 +284,7 @@ def simplify_switch_clusters(
             continue
 
         # each switch region belongs to a conditional region
-        switch_region_to_parent_region: Dict[SwitchCaseRegion, Tuple[ConditionalRegion, str]] = {}
+        switch_region_to_parent_region: dict[SwitchCaseRegion, tuple[ConditionalRegion, str]] = {}
         used_condnodes_and_branch = set()
         for r in switch_regions:
             for cr in cond_regions:
@@ -337,20 +337,20 @@ def simplify_switch_clusters(
         used_condnodes = list(condnode for condnode, _ in used_condnodes_and_branch)
 
         # collect addresses for all case nodes
-        case_addr_to_case_id: Dict[int, Union[int, Tuple[int, ...], str]] = {}
+        case_addr_to_case_id: dict[int, int | tuple[int, ...] | str] = {}
         for sr in switch_regions:
             for case_id, case_node in sr.node.cases.items():
                 case_addr_to_case_id[case_node.addr] = case_id
             if sr.node.default_node is not None:
                 case_addr_to_case_id[sr.node.default_node.addr] = "default"
-        case_addrs: Set[int] = set(case_addr_to_case_id)
+        case_addrs: set[int] = set(case_addr_to_case_id)
 
         # filter cond_regions
         mergeable_cond_regions = filter_cond_regions(cond_regions, case_addrs)
 
         # list all unmatched conditional nodes
-        standalone_condnodes: List[Tuple[ConditionalRegion, str]] = []
-        standalone_condjumps: List[ConditionalRegion] = []
+        standalone_condnodes: list[tuple[ConditionalRegion, str]] = []
+        standalone_condjumps: list[ConditionalRegion] = []
         for cr in mergeable_cond_regions:
             if isinstance(cr.node, ConditionNode):
                 if cr.node.true_node is not None and (cr, "true") not in used_condnodes_and_branch:
@@ -487,7 +487,7 @@ def simplify_switch_clusters(
             continue
 
 
-def simplify_lowered_switches(region: SequenceNode, var2condnodes: Dict[Any, List[ConditionalRegion]], functions):
+def simplify_lowered_switches(region: SequenceNode, var2condnodes: dict[Any, list[ConditionalRegion]], functions):
     """
     Identify a lowered switch and simplify it into a switch-case if possible.
 
@@ -522,8 +522,8 @@ def simplify_lowered_switches_core(
         return False
 
     caseno_to_node = {}
-    default_node_candidates: List[Tuple[BaseNode, BaseNode]] = []  # parent to default node candidate
-    stack: List[(ConditionNode, int, int)] = [(outermost_node, 0, 0xFFFF_FFFF_FFFF_FFFF)]
+    default_node_candidates: list[tuple[BaseNode, BaseNode]] = []  # parent to default node candidate
+    stack: list[(ConditionNode, int, int)] = [(outermost_node, 0, 0xFFFF_FFFF_FFFF_FFFF)]
     while stack:
         node, min_, max_ = stack.pop(0)
         if node not in node_to_condnode:
@@ -632,7 +632,7 @@ class FindFirstNodeInSet(SequenceWalker):
     Find the first node out of a set of node appearing in a SequenceNode (and its tree).
     """
 
-    def __init__(self, node_set: Set[BaseNode]):
+    def __init__(self, node_set: set[BaseNode]):
         super().__init__(update_seqnode_in_place=False, force_forward_scan=True)
         self.node_set = node_set
         self.first_node = None