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

angr/analyses/typehoon/typeconsts.py

@@ -3,7 +3,6 @@
 All type constants used in type inference. They can be mapped, translated, or rewritten to C-style types.
 """
 
-from typing import List, Optional, Set
 import functools
 
 
@@ -30,7 +29,7 @@ class TypeConstant:
     def pp_str(self, mapping) -> str:  # pylint:disable=unused-argument
         return repr(self)
 
-    def _hash(self, visited: Set[int]):  # pylint:disable=unused-argument
+    def _hash(self, visited: set[int]):  # pylint:disable=unused-argument
         return hash(type(self))
 
     def __eq__(self, other):
@@ -123,13 +122,13 @@ class Double(FloatBase):
 
 
 class Pointer(TypeConstant):
-    def __init__(self, basetype: Optional[TypeConstant]):
-        self.basetype: Optional[TypeConstant] = basetype
+    def __init__(self, basetype: TypeConstant | None):
+        self.basetype: TypeConstant | None = basetype
 
     def __eq__(self, other):
         return type(self) is type(other) and self.basetype == other.basetype
 
-    def _hash(self, visited: Set[int]):
+    def _hash(self, visited: set[int]):
         if self.basetype is None:
             return hash(type(self))
         return hash((type(self), self.basetype._hash(visited)))
@@ -171,8 +170,8 @@ class Pointer64(Pointer, Int64):
 
 class Array(TypeConstant):
     def __init__(self, element=None, count=None):
-        self.element: Optional[TypeConstant] = element
-        self.count: Optional[int] = count
+        self.element: TypeConstant | None = element
+        self.count: int | None = count
 
     @memoize
     def __repr__(self, memo=None):
@@ -184,7 +183,7 @@ class Array(TypeConstant):
     def __eq__(self, other):
         return type(other) is type(self) and self.element == other.element and self.count == other.count
 
-    def _hash(self, visited: Set[int]):
+    def _hash(self, visited: set[int]):
         if id(self) in visited:
             return 0
         visited.add(id(self))
@@ -200,13 +199,13 @@ class Struct(TypeConstant):
         self.name = name
         self.field_names = field_names
 
-    def _hash(self, visited: Set[int]):
+    def _hash(self, visited: set[int]):
         if id(self) in visited:
             return 0
         visited.add(id(self))
         return hash((type(self), self._hash_fields(visited)))
 
-    def _hash_fields(self, visited: Set[int]):
+    def _hash_fields(self, visited: set[int]):
         keys = sorted(self.fields.keys())
         tpl = tuple((k, self.fields[k]._hash(visited) if self.fields[k] is not None else None) for k in keys)
         return hash(tpl)
@@ -226,7 +225,7 @@ class Struct(TypeConstant):
 
 
 class Function(TypeConstant):
-    def __init__(self, params: List, outputs: List):
+    def __init__(self, params: list, outputs: list):
         self.params = params
         self.outputs = outputs
 
@@ -241,7 +240,7 @@ class Function(TypeConstant):
             return False
         return self.params == other.params and self.outputs == other.outputs
 
-    def _hash(self, visited: Set[int]):
+    def _hash(self, visited: set[int]):
         if id(self) in visited:
             return 0
         visited.add(id(self))
@@ -273,7 +272,7 @@ class TypeVariableReference(TypeConstant):
 #
 
 
-def int_type(bits: int) -> Optional[Int]:
+def int_type(bits: int) -> Int | None:
     mapping = {
         1: Int1,
         8: Int8,
@@ -287,7 +286,7 @@ def int_type(bits: int) -> Optional[Int]:
     return None
 
 
-def float_type(bits: int) -> Optional[FloatBase]:
+def float_type(bits: int) -> FloatBase | None:
     if bits == 32:
         return Float()
     elif bits == 64:

angr/analyses/typehoon/typehoon.py

@@ -1,5 +1,5 @@
 # pylint:disable=bad-builtin
-from typing import List, Set, Optional, Dict, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from ...sim_type import SimStruct, SimTypePointer, SimTypeArray
 from ..analysis import Analysis, AnalysesHub
@@ -33,8 +33,8 @@ class Typehoon(Analysis):
         constraints,
         func_var,
         ground_truth=None,
-        var_mapping: Optional[Dict["SimVariable", Set["TypeVariable"]]] = None,
-        must_struct: Optional[Set["TypeVariable"]] = None,
+        var_mapping: dict["SimVariable", set["TypeVariable"]] | None = None,
+        must_struct: set["TypeVariable"] | None = None,
     ):
         """
 
@@ -46,8 +46,8 @@ class Typehoon(Analysis):
         """
 
         self.func_var: "TypeVariable" = func_var
-        self._constraints: Dict["TypeVariable", Set["TypeConstraint"]] = constraints
-        self._ground_truth: Optional[Dict["TypeVariable", "SimType"]] = ground_truth
+        self._constraints: dict["TypeVariable", set["TypeConstraint"]] = constraints
+        self._ground_truth: dict["TypeVariable", "SimType"] | None = ground_truth
         self._var_mapping = var_mapping
         self._must_struct = must_struct
 
@@ -66,7 +66,7 @@ class Typehoon(Analysis):
     # Public methods
     #
 
-    def update_variable_types(self, func_addr: Union[int, str], var_to_typevars):
+    def update_variable_types(self, func_addr: int | str, var_to_typevars):
         for var, typevars in var_to_typevars.items():
             for typevar in typevars:
                 type_ = self.simtypes_solution.get(typevar, None)
@@ -179,7 +179,7 @@ class Typehoon(Analysis):
             if specialized is not None:
                 self.solution[tv] = specialized
 
-    def _specialize_struct(self, tc, memo: Optional[Set] = None):
+    def _specialize_struct(self, tc, memo: set | None = None):
         if isinstance(tc, Pointer):
             if memo is not None and tc in memo:
                 return None
@@ -188,8 +188,8 @@ class Typehoon(Analysis):
                 return None
             return tc.new(specialized)
 
-        if isinstance(tc, Struct) and tc.fields:
-            offsets: List[int] = sorted(list(tc.fields.keys()))  # get a sorted list of offsets
+        if isinstance(tc, Struct) and tc.fields and min(tc.fields) >= 0:
+            offsets: list[int] = sorted(list(tc.fields.keys()))  # get a sorted list of offsets
             offset0 = offsets[0]
             field0: TypeConstant = tc.fields[offset0]
 

angr/analyses/typehoon/typevars.py

@@ -1,5 +1,6 @@
 # pylint:disable=missing-class-docstring
-from typing import Dict, Any, Optional, Set, Iterable, Tuple, Union, TYPE_CHECKING
+from typing import Any, Optional, Union, TYPE_CHECKING
+from collections.abc import Iterable
 from itertools import count
 
 from angr.utils.constants import MAX_POINTSTO_BITS
@@ -18,7 +19,7 @@ TypeType = Union["TypeConstant", "TypeVariable", "DerivedTypeVariable"]
 class TypeConstraint:
     __slots__ = ()
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         raise NotImplementedError()
 
 
@@ -32,7 +33,7 @@ class Equivalence(TypeConstraint):
         self.type_a = type_a
         self.type_b = type_b
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         return f"{self.type_a.pp_str(mapping)} == {self.type_b.pp_str(mapping)}"
 
     def __repr__(self):
@@ -56,7 +57,7 @@ class Existence(TypeConstraint):
     def __init__(self, type_):
         self.type_ = type_
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         return f"V {self.type_.pp_str(mapping)}"
 
     def __repr__(self):
@@ -89,7 +90,7 @@ class Subtype(TypeConstraint):
         self.super_type = super_type
         self.sub_type = sub_type
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         return f"{self.sub_type.pp_str(mapping)} <: {self.super_type.pp_str(mapping)}"
 
     def __repr__(self):
@@ -146,7 +147,7 @@ class Add(TypeConstraint):
         self.type_1 = type_1
         self.type_r = type_r
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         return "{} == {} + {}".format(
             self.type_r.pp_str(mapping),
             self.type_0.pp_str(mapping),
@@ -218,7 +219,7 @@ class Sub(TypeConstraint):
         self.type_1 = type_1
         self.type_r = type_r
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         return "{} == {} - {}".format(
             self.type_r.pp_str(mapping),
             self.type_0.pp_str(mapping),
@@ -280,14 +281,14 @@ _typevariable_counter = count()
 class TypeVariable:
     __slots__ = ("idx", "name")
 
-    def __init__(self, idx: Optional[int] = None, name: Optional[str] = None):
+    def __init__(self, idx: int | None = None, name: str | None = None):
         if idx is None:
             self.idx: int = next(_typevariable_counter)
         else:
             self.idx: int = idx
         self.name = name
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         varname = mapping.get(self, self.name)
         if varname is None:
             return repr(self)
@@ -321,9 +322,9 @@ class DerivedTypeVariable(TypeVariable):
 
     def __init__(
         self,
-        type_var: Optional[Union[TypeVariable, "DerivedTypeVariable"]],
+        type_var: Union[TypeVariable, "DerivedTypeVariable"] | None,
         label,
-        labels: Optional[Iterable["BaseLabel"]] = None,
+        labels: Iterable["BaseLabel"] | None = None,
         idx=None,
     ):
         super().__init__(idx=idx)
@@ -341,7 +342,7 @@ class DerivedTypeVariable(TypeVariable):
         if label is not None:
             self.labels = existing_labels + (label,)
         else:
-            self.labels: Tuple["BaseLabel"] = existing_labels + tuple(labels)
+            self.labels: tuple["BaseLabel"] = existing_labels + tuple(labels)
 
         if not self.labels:
             raise ValueError("A DerivedTypeVariable must have at least one label")
@@ -349,17 +350,17 @@ class DerivedTypeVariable(TypeVariable):
     def one_label(self) -> Optional["BaseLabel"]:
         return self.labels[0] if len(self.labels) == 1 else None
 
-    def path(self) -> Tuple["BaseLabel"]:
+    def path(self) -> tuple["BaseLabel"]:
         return self.labels
 
-    def longest_prefix(self) -> Optional[Union[TypeVariable, "DerivedTypeVariable"]]:
+    def longest_prefix(self) -> Union[TypeVariable, "DerivedTypeVariable"] | None:
         if not self.labels:
             return None
         if len(self.labels) == 1:
             return self.type_var
         return DerivedTypeVariable(self.type_var, None, labels=self.labels[:-1])
 
-    def pp_str(self, mapping: Dict["TypeVariable", Any]) -> str:
+    def pp_str(self, mapping: dict["TypeVariable", Any]) -> str:
         return ".".join([self.type_var.pp_str(mapping)] + [repr(lbl) for lbl in self.labels])
 
     def __eq__(self, other):
@@ -401,8 +402,8 @@ class TypeVariables:
     )
 
     def __init__(self):
-        self._typevars: Dict["SimVariable", Set[TypeVariable]] = {}
-        self._last_typevars: Dict[SimVariable, TypeVariable] = {}
+        self._typevars: dict["SimVariable", set[TypeVariable]] = {}
+        self._last_typevars: dict[SimVariable, TypeVariable] = {}
 
     def copy(self):
         copied = TypeVariables()

angr/analyses/variable_recovery/engine_ail.py

@@ -1,5 +1,5 @@
 # pylint:disable=arguments-differ,invalid-unary-operand-type
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 import logging
 
 import ailment
@@ -81,7 +81,7 @@ class SimEngineVRAIL(
     def _ail_handle_ConditionalJump(self, stmt):
         self._expr(stmt.condition)
 
-    def _ail_handle_Call(self, stmt: ailment.Stmt.Call, is_expr=False) -> Optional[RichR]:
+    def _ail_handle_Call(self, stmt: ailment.Stmt.Call, is_expr=False) -> RichR | None:
         target = stmt.target
         args = []
         if stmt.args:
@@ -98,7 +98,7 @@ class SimEngineVRAIL(
         create_variable = True
         if not is_expr:
             # this is a call statement. we need to update the return value register later
-            ret_expr: Optional[ailment.Expr.Register] = stmt.ret_expr
+            ret_expr: ailment.Expr.Register | None = stmt.ret_expr
             if ret_expr is not None:
                 ret_reg_offset = ret_expr.reg_offset
                 ret_expr_bits = ret_expr.bits
@@ -130,8 +130,8 @@ class SimEngineVRAIL(
             self.state.add_type_constraint(typevars.Subtype(funcaddr_typevar, load_typevar))
 
         # discover the prototype
-        prototype: Optional[SimTypeFunction] = None
-        prototype_libname: Optional[str] = None
+        prototype: SimTypeFunction | None = None
+        prototype_libname: str | None = None
         if stmt.prototype is not None:
             prototype = stmt.prototype
         if isinstance(stmt.target, ailment.Expr.Const):

angr/analyses/variable_recovery/engine_base.py

@@ -1,6 +1,7 @@
-from typing import Optional, Set, List, Tuple, Union, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 import logging
 
+import ailment
 import claripy
 
 from ...storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
@@ -38,7 +39,7 @@ class RichR:
         self,
         data: claripy.ast.Base,
         variable=None,
-        typevar: Optional[typevars.TypeVariable] = None,
+        typevar: typevars.TypeVariable | None = None,
         type_constraints=None,
     ):
         self.data: claripy.ast.Base = data
@@ -110,7 +111,7 @@ class SimEngineVRBase(SimEngineLight):
         return False
 
     @staticmethod
-    def _parse_offseted_addr(addr: claripy.ast.BV) -> Optional[Tuple[claripy.ast.BV, claripy.ast.BV, claripy.ast.BV]]:
+    def _parse_offseted_addr(addr: claripy.ast.BV) -> tuple[claripy.ast.BV, claripy.ast.BV, claripy.ast.BV] | None:
         if addr.op == "__add__":
             if len(addr.args) == 2:
                 concrete_base, byte_offset = None, None
@@ -142,7 +143,7 @@ class SimEngineVRBase(SimEngineLight):
 
     def _ensure_variable_existence(
         self, richr_addr: RichR, codeloc: CodeLocation, src_expr=None
-    ) -> Optional[List[Tuple[SimVariable, int]]]:
+    ) -> list[tuple[SimVariable, int]] | None:
         data: claripy.ast.Base = richr_addr.data
 
         if data is None:
@@ -151,15 +152,15 @@ class SimEngineVRBase(SimEngineLight):
         if self.state.is_stack_address(data):
             # this is a stack address
             # extract stack offset
-            stack_offset: Optional[int] = self.state.get_stack_offset(data)
+            stack_offset: int | None = self.state.get_stack_offset(data)
 
             variable_manager = self.variable_manager[self.func_addr]
-            var_candidates: List[Tuple[SimVariable, int]] = variable_manager.find_variables_by_stmt(
+            var_candidates: list[tuple[SimVariable, int]] = variable_manager.find_variables_by_stmt(
                 self.block.addr, self.stmt_idx, "memory"
             )
 
             # find the correct variable
-            existing_vars: List[Tuple[SimVariable, int]] = []
+            existing_vars: list[tuple[SimVariable, int]] = []
             for candidate, offset in var_candidates:
                 if isinstance(candidate, SimStackVariable) and candidate.offset == stack_offset:
                     existing_vars.append((candidate, offset))
@@ -173,7 +174,7 @@ class SimEngineVRBase(SimEngineLight):
                 if variable is None:
                     # TODO: how to determine the size for a lea?
                     try:
-                        vs: Optional[MultiValues] = self.state.stack_region.load(stack_addr, size=1)
+                        vs: MultiValues | None = self.state.stack_region.load(stack_addr, size=1)
                     except SimMemoryMissingError:
                         vs = None
 
@@ -248,15 +249,18 @@ class SimEngineVRBase(SimEngineLight):
         if self.state.is_stack_address(data):
             # this is a stack address
             # extract stack offset
-            stack_offset: Optional[int] = self.state.get_stack_offset(data)
+            stack_offset: int | None = self.state.get_stack_offset(data)
 
             variable_manager = self.variable_manager[self.func_addr]
-            var_candidates: List[Tuple[SimVariable, int]] = variable_manager.find_variables_by_stmt(
-                self.block.addr, self.stmt_idx, "memory"
+            var_candidates: list[tuple[SimVariable, int]] = variable_manager.find_variables_by_stmt(
+                self.block.addr,
+                self.stmt_idx,
+                "memory",
+                block_idx=self.block.idx if isinstance(self.block, ailment.Block) else None,
             )
 
             # find the correct variable
-            existing_vars: List[Tuple[SimVariable, int]] = []
+            existing_vars: list[tuple[SimVariable, int]] = []
             for candidate, offset in var_candidates:
                 if isinstance(candidate, SimStackVariable) and candidate.offset == stack_offset:
                     existing_vars.append((candidate, offset))
@@ -313,7 +317,7 @@ class SimEngineVRBase(SimEngineLight):
         # handle register writes
 
         # first check if there is an existing variable for the atom at this location already
-        existing_vars: Set[Tuple[SimVariable, int]] = self.variable_manager[self.func_addr].find_variables_by_atom(
+        existing_vars: set[tuple[SimVariable, int]] = self.variable_manager[self.func_addr].find_variables_by_atom(
             self.block.addr, self.stmt_idx, dst
         )
         if not existing_vars:
@@ -473,8 +477,8 @@ class SimEngineVRBase(SimEngineLight):
         data: RichR,
         size: int,
         stmt=None,
-        offset: Optional[claripy.ast.BV] = None,
-        elem_size: Optional[claripy.ast.BV] = None,
+        offset: claripy.ast.BV | None = None,
+        elem_size: claripy.ast.BV | None = None,
     ):
         variable_manager = self.variable_manager["global"]
         if stmt is None:
@@ -636,7 +640,7 @@ class SimEngineVRBase(SimEngineLight):
                     dynamic_offset = None
 
                 try:
-                    values: Optional[MultiValues] = self.state.stack_region.load(
+                    values: MultiValues | None = self.state.stack_region.load(
                         self.state.stack_addr_from_offset(concrete_offset),
                         size=size,
                         endness=self.state.arch.memory_endness,
@@ -645,7 +649,7 @@ class SimEngineVRBase(SimEngineLight):
                 except SimMemoryMissingError:
                     values = None
 
-                all_vars: Set[Tuple[int, SimVariable]] = set()
+                all_vars: set[tuple[int, SimVariable]] = set()
                 if values:
                     for vs in values.values():
                         for v in vs:
@@ -788,8 +792,8 @@ class SimEngineVRBase(SimEngineLight):
         addr: int,
         size,
         expr=None,
-        offset: Optional[claripy.ast.BV] = None,
-        elem_size: Optional[claripy.ast.BV] = None,
+        offset: claripy.ast.BV | None = None,
+        elem_size: claripy.ast.BV | None = None,
     ) -> RichR:
         variable_manager = self.variable_manager["global"]
         if expr is None:
@@ -862,7 +866,7 @@ class SimEngineVRBase(SimEngineLight):
         codeloc = self._codeloc()
 
         try:
-            values: Optional[MultiValues] = self.state.register_region.load(offset, size=size)
+            values: MultiValues | None = self.state.register_region.load(offset, size=size)
         except SimMemoryMissingError:
             values = None
 
@@ -935,7 +939,7 @@ class SimEngineVRBase(SimEngineLight):
         return RichR(r_value, variable=var, typevar=typevar)
 
     def _create_access_typevar(
-        self, typevar: Union[TypeVariable, DerivedTypeVariable], is_store: bool, size: int, offset: int
+        self, typevar: TypeVariable | DerivedTypeVariable, is_store: bool, size: int, offset: int
     ) -> DerivedTypeVariable:
         if isinstance(typevar, DerivedTypeVariable):
             if isinstance(typevar.labels[-1], AddN):

angr/analyses/variable_recovery/irsb_scanner.py

@@ -1,5 +1,4 @@
 # pylint:disable=no-self-use,unused-argument
-from typing import Set, Dict
 
 import pyvex
 
@@ -17,10 +16,10 @@ class VEXIRSBScanner(SimEngineLightVEXMixin):
 
         # the following variables are for narrowing argument-passing register on 64-bit architectures. they are
         # initialized before processing each block.
-        self.tmps_with_64bit_regs: Set[int] = set()  # tmps that store 64-bit register values
-        self.tmps_converted_to_32bit: Set[int] = set()  # tmps that store the 64-to-32-bit converted values
-        self.tmps_assignment_stmtidx: Dict[int, int] = {}  # statement IDs for the assignment of each tmp
-        self.stmts_to_lower: Set[int] = set()
+        self.tmps_with_64bit_regs: set[int] = set()  # tmps that store 64-bit register values
+        self.tmps_converted_to_32bit: set[int] = set()  # tmps that store the 64-to-32-bit converted values
+        self.tmps_assignment_stmtidx: dict[int, int] = {}  # statement IDs for the assignment of each tmp
+        self.stmts_to_lower: set[int] = set()
 
         # the following variables are for recognizing redundant argument register reads in gcc(?) -O0 binaries.
         # e.g.,
@@ -28,10 +27,10 @@ class VEXIRSBScanner(SimEngineLightVEXMixin):
         #    mov rdi, rax
         #
         # we will not create a variable for the register read in the first instruction (read from r9) in this case.
-        self.tmp_with_reg_as_value: Dict[int, int] = {}
-        self.reg_with_reg_as_value: Dict[int, int] = {}
-        self.reg_read_stmt_id: Dict[int, int] = {}
-        self.reg_read_stmts_to_ignore: Set[int] = set()
+        self.tmp_with_reg_as_value: dict[int, int] = {}
+        self.reg_with_reg_as_value: dict[int, int] = {}
+        self.reg_read_stmt_id: dict[int, int] = {}
+        self.reg_read_stmts_to_ignore: set[int] = set()
 
     def _top(self, size: int):
         return None

angr/analyses/variable_recovery/variable_recovery.py

@@ -1,6 +1,5 @@
 import logging
 from collections import defaultdict
-from typing import Tuple
 
 import claripy
 
@@ -90,7 +89,7 @@ class VariableRecoveryState(VariableRecoveryStateBase):
             )
             concrete_state.inspect.add_breakpoint("mem_write", BP(enabled=True, action=self._hook_memory_write))
 
-    def merge(self, others: Tuple["VariableRecoveryState"], successor=None) -> Tuple["VariableRecoveryState", bool]:
+    def merge(self, others: tuple["VariableRecoveryState"], successor=None) -> tuple["VariableRecoveryState", bool]:
         """
         Merge two abstract states.
 

angr/analyses/variable_recovery/variable_recovery_base.py

@@ -1,5 +1,6 @@
 import weakref
-from typing import List, Generator, Iterable, Tuple, Union, Set, Optional, Dict, Any, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
+from collections.abc import Generator, Iterable
 import logging
 from collections import defaultdict
 
@@ -51,7 +52,7 @@ def parse_stack_pointer(sp):
 class VariableAnnotation(Annotation):
     __slots__ = ("addr_and_variables",)
 
-    def __init__(self, addr_and_variables: List[Tuple[int, SimVariable]]):
+    def __init__(self, addr_and_variables: list[tuple[int, SimVariable]]):
         self.addr_and_variables = addr_and_variables
 
     @property
@@ -87,7 +88,7 @@ class VariableRecoveryBase(Analysis):
         self._store_live_variables = store_live_variables
 
         self._outstates = {}
-        self._instates: Dict[Any, VariableRecoveryStateBase] = {}
+        self._instates: dict[Any, VariableRecoveryStateBase] = {}
         self._dominance_frontiers = None
 
     #
@@ -211,8 +212,8 @@ class VariableRecoveryStateBase:
         self.global_region.set_state(self)
 
         # Used during merging
-        self.successor_block_addr: Optional[int] = None
-        self.phi_variables: Dict[SimVariable, SimVariable] = {}
+        self.successor_block_addr: int | None = None
+        self.phi_variables: dict[SimVariable, SimVariable] = {}
 
         self.typevars = TypeVariables() if typevars is None else typevars
         self.type_constraints = defaultdict(set) if type_constraints is None else type_constraints
@@ -222,7 +223,7 @@ class VariableRecoveryStateBase:
             if delayed_type_constraints is None
             else delayed_type_constraints
         )
-        self.stack_offset_typevars: Dict[int, TypeVariable] = (
+        self.stack_offset_typevars: dict[int, TypeVariable] = (
             {} if stack_offset_typevars is None else stack_offset_typevars
         )
 
@@ -244,14 +245,14 @@ class VariableRecoveryStateBase:
         return False
 
     @staticmethod
-    def extract_variables(expr: claripy.ast.Base) -> Generator[Tuple[int, Union[SimVariable, SpOffset]], None, None]:
+    def extract_variables(expr: claripy.ast.Base) -> Generator[tuple[int, SimVariable | SpOffset], None, None]:
         for anno in expr.annotations:
             if isinstance(anno, VariableAnnotation):
                 yield from anno.addr_and_variables
 
     @staticmethod
     def annotate_with_variables(
-        expr: claripy.ast.Base, addr_and_variables: Iterable[Tuple[int, Union[SimVariable, SpOffset]]]
+        expr: claripy.ast.Base, addr_and_variables: Iterable[tuple[int, SimVariable | SpOffset]]
     ) -> claripy.ast.Base:
         expr = expr.replace_annotations((VariableAnnotation(list(addr_and_variables)),))
         return expr
@@ -276,7 +277,7 @@ class VariableRecoveryStateBase:
         return False
 
     @staticmethod
-    def extract_stack_offset_from_addr(addr: claripy.ast.Base) -> Optional[claripy.ast.Base]:
+    def extract_stack_offset_from_addr(addr: claripy.ast.Base) -> claripy.ast.Base | None:
         r = None
         if addr.op == "BVS":
             if addr.args[0] == "stack_base":
@@ -300,7 +301,7 @@ class VariableRecoveryStateBase:
             r = r1 - r2
         return r
 
-    def get_stack_offset(self, addr: claripy.ast.Base) -> Optional[int]:
+    def get_stack_offset(self, addr: claripy.ast.Base) -> int | None:
         if "stack_base" in addr.variables:
             r = VariableRecoveryStateBase.extract_stack_offset_from_addr(addr)
             if r is None:
@@ -406,17 +407,17 @@ class VariableRecoveryStateBase:
 
     @staticmethod
     def _mo_cmp(
-        mos_self: Set["SimMemoryObject"], mos_other: Set["SimMemoryObject"], addr: int, size: int
+        mos_self: set["SimMemoryObject"], mos_other: set["SimMemoryObject"], addr: int, size: int
     ):  # pylint:disable=unused-argument
         # comparing bytes from two sets of memory objects
         # we don't need to resort to byte-level comparison. object-level is good enough.
 
         return mos_self == mos_other
 
-    def _make_phi_variable(self, values: Set[claripy.ast.Base]) -> Optional[claripy.ast.Base]:
+    def _make_phi_variable(self, values: set[claripy.ast.Base]) -> claripy.ast.Base | None:
         # we only create a new phi variable if the there is at least one variable involved
         variables = set()
-        bits: Optional[int] = None
+        bits: int | None = None
         for v in values:
             bits = v.size()
             for _, var in self.extract_variables(v):