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

angr/knowledge_plugins/key_definitions/live_definitions.py

@@ -1,4 +1,5 @@
-from typing import Optional, Iterable, Dict, Set, Generator, Tuple, Union, Any, TYPE_CHECKING, overload, Type
+from typing import Optional, Union, Any, TYPE_CHECKING, overload
+from collections.abc import Iterable, Generator
 import weakref
 import logging
 from enum import Enum, auto
@@ -182,8 +183,8 @@ class LiveDefinitions:
             if heap is None
             else heap
         )
-        self.tmps: Dict[int, Set[Definition]] = {} if tmps is None else tmps
-        self.others: Dict[Atom, MultiValues] = others if others is not None else {}
+        self.tmps: dict[int, set[Definition]] = {} if tmps is None else tmps
+        self.others: dict[Atom, MultiValues] = others if others is not None else {}
 
         # set state
         self.registers.set_state(self)
@@ -195,10 +196,10 @@ class LiveDefinitions:
         self.stack_uses = Uses() if stack_uses is None else stack_uses
         self.heap_uses = Uses() if heap_uses is None else heap_uses
         self.memory_uses = Uses() if memory_uses is None else memory_uses
-        self.tmp_uses: Dict[int, Set[CodeLocation]] = defaultdict(set) if tmp_uses is None else tmp_uses
+        self.tmp_uses: dict[int, set[CodeLocation]] = defaultdict(set) if tmp_uses is None else tmp_uses
         self.other_uses = Uses() if other_uses is None else other_uses
 
-        self.uses_by_codeloc: Dict[CodeLocation, Set[Definition]] = defaultdict(set)
+        self.uses_by_codeloc: dict[CodeLocation, set[Definition]] = defaultdict(set)
 
     @property
     @deprecated("registers")
@@ -260,8 +261,8 @@ class LiveDefinitions:
 
     @staticmethod
     def _mo_cmp(
-        mo_self: Union["SimMemoryObject", Set["SimMemoryObject"]],
-        mo_other: Union["SimMemoryObject", Set["SimMemoryObject"]],
+        mo_self: Union["SimMemoryObject", set["SimMemoryObject"]],
+        mo_other: Union["SimMemoryObject", set["SimMemoryObject"]],
         addr: int,
         size: int,
     ):  # pylint:disable=unused-argument
@@ -317,7 +318,7 @@ class LiveDefinitions:
                 return True
         return False
 
-    def stack_address(self, offset: int) -> Optional[claripy.ast.bv.BV]:
+    def stack_address(self, offset: int) -> claripy.ast.bv.BV | None:
         base = claripy.BVS("stack_base", self.arch.bits, explicit_name=True)
         if offset:
             return base + offset
@@ -328,7 +329,7 @@ class LiveDefinitions:
         return "stack_base" in addr.variables
 
     @staticmethod
-    def get_stack_offset(addr: claripy.ast.Base, had_stack_base=False) -> Optional[int]:
+    def get_stack_offset(addr: claripy.ast.Base, had_stack_base=False) -> int | None:
         if had_stack_base and addr.op == "BVV":
             assert isinstance(addr, claripy.ast.BV)
             return addr.concrete_value
@@ -377,7 +378,7 @@ class LiveDefinitions:
                 yield anno.definition
 
     @staticmethod
-    def extract_defs_from_annotations(annos: Iterable["Annotation"]) -> Set[Definition]:
+    def extract_defs_from_annotations(annos: Iterable["Annotation"]) -> set[Definition]:
         defs = set()
         for anno in annos:
             if isinstance(anno, DefinitionAnnotation):
@@ -410,7 +411,7 @@ class LiveDefinitions:
         assert result is not None
         return result
 
-    def get_sp_offset(self) -> Optional[int]:
+    def get_sp_offset(self) -> int | None:
         """
         Return the offset of the stack pointer.
         """
@@ -426,7 +427,7 @@ class LiveDefinitions:
         result = self.get_stack_offset(sp_v)
         return result
 
-    def get_stack_address(self, offset: claripy.ast.Base) -> Optional[int]:
+    def get_stack_address(self, offset: claripy.ast.Base) -> int | None:
         offset_int = self.get_stack_offset(offset)
         if offset_int is None:
             return None
@@ -443,7 +444,7 @@ class LiveDefinitions:
             raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
         return (base_v + offset) & mask
 
-    def merge(self, *others: "LiveDefinitions") -> Tuple["LiveDefinitions", bool]:
+    def merge(self, *others: "LiveDefinitions") -> tuple["LiveDefinitions", bool]:
         state = self.copy()
 
         merge_occurred = state.registers.merge([other.registers for other in others], None)
@@ -545,10 +546,10 @@ class LiveDefinitions:
         code_loc: CodeLocation,
         data: MultiValues,
         dummy=False,
-        tags: Optional[Set[Tag]] = None,
+        tags: set[Tag] | None = None,
         endness=None,
         annotated=False,
-    ) -> Optional[MultiValues]:
+    ) -> MultiValues | None:
         if data is None:
             raise TypeError("kill_and_add_definition() does not take None as data.")
 
@@ -612,7 +613,7 @@ class LiveDefinitions:
 
         return d
 
-    def add_use(self, atom: Atom, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_use(self, atom: Atom, code_loc: CodeLocation, expr: Any | None = None) -> None:
         if isinstance(atom, Register):
             self.add_register_use(atom.reg_offset, atom.size, code_loc, expr=expr)
         elif isinstance(atom, MemoryLocation):
@@ -654,8 +655,8 @@ class LiveDefinitions:
             self.other_uses.add_use(definition, code_loc, expr)
 
     def get_definitions(
-        self, thing: Union[Atom, Definition[Atom], Iterable[Atom], Iterable[Definition[Atom]], MultiValues]
-    ) -> Set[Definition[Atom]]:
+        self, thing: Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]] | MultiValues
+    ) -> set[Definition[Atom]]:
         if isinstance(thing, MultiValues):
             defs = set()
             for vs in thing.values():
@@ -692,13 +693,13 @@ class LiveDefinitions:
                     defs |= self.get_definitions(mv)
             return defs
 
-    def get_tmp_definitions(self, tmp_idx: int) -> Set[Definition]:
+    def get_tmp_definitions(self, tmp_idx: int) -> set[Definition]:
         if tmp_idx in self.tmps:
             return self.tmps[tmp_idx]
         else:
             return set()
 
-    def get_register_definitions(self, reg_offset: int, size: int) -> Set[Definition]:
+    def get_register_definitions(self, reg_offset: int, size: int) -> set[Definition]:
         try:
             annotations = self.registers.load_annotations(reg_offset, size)
         except SimMemoryMissingError as ex:
@@ -710,14 +711,14 @@ class LiveDefinitions:
 
         return LiveDefinitions.extract_defs_from_annotations(annotations)
 
-    def get_stack_values(self, stack_offset: int, size: int, endness: str) -> Optional[MultiValues]:
+    def get_stack_values(self, stack_offset: int, size: int, endness: str) -> MultiValues | None:
         stack_addr = self.stack_offset_to_stack_addr(stack_offset)
         try:
             return self.stack.load(stack_addr, size=size, endness=endness)
         except SimMemoryMissingError:
             return None
 
-    def get_stack_definitions(self, stack_offset: int, size: int) -> Set[Definition]:
+    def get_stack_definitions(self, stack_offset: int, size: int) -> set[Definition]:
         try:
             stack_addr = self.stack_offset_to_stack_addr(stack_offset)
             annotations = self.stack.load_annotations(stack_addr, size)
@@ -726,7 +727,7 @@ class LiveDefinitions:
 
         return LiveDefinitions.extract_defs_from_annotations(annotations)
 
-    def get_heap_definitions(self, heap_addr: int, size: int) -> Set[Definition]:
+    def get_heap_definitions(self, heap_addr: int, size: int) -> set[Definition]:
         try:
             annotations = self.heap.load_annotations(heap_addr, size)
         except SimMemoryMissingError:
@@ -734,7 +735,7 @@ class LiveDefinitions:
 
         return LiveDefinitions.extract_defs_from_annotations(annotations)
 
-    def get_memory_definitions(self, addr: int, size: int) -> Set[Definition]:
+    def get_memory_definitions(self, addr: int, size: int) -> set[Definition]:
         try:
             annotations = self.memory.load_annotations(addr, size)
         except SimMemoryMissingError:
@@ -750,19 +751,19 @@ class LiveDefinitions:
         return result
 
     @deprecated("get_values")
-    def get_value_from_definition(self, definition: Definition) -> Optional[MultiValues]:
+    def get_value_from_definition(self, definition: Definition) -> MultiValues | None:
         return self.get_value_from_atom(definition.atom)
 
     @deprecated("get_one_value")
-    def get_one_value_from_definition(self, definition: Definition) -> Optional[claripy.ast.bv.BV]:
+    def get_one_value_from_definition(self, definition: Definition) -> claripy.ast.bv.BV | None:
         return self.get_one_value_from_atom(definition.atom)
 
     @deprecated("get_concrete_value")
-    def get_concrete_value_from_definition(self, definition: Definition) -> Optional[int]:
+    def get_concrete_value_from_definition(self, definition: Definition) -> int | None:
         return self.get_concrete_value_from_atom(definition.atom)
 
     @deprecated("get_values")
-    def get_value_from_atom(self, atom: Atom) -> Optional[MultiValues]:
+    def get_value_from_atom(self, atom: Atom) -> MultiValues | None:
         if isinstance(atom, Register):
             try:
                 return self.registers.load(atom.reg_offset, size=atom.size)
@@ -792,14 +793,14 @@ class LiveDefinitions:
             return None
 
     @deprecated("get_one_value")
-    def get_one_value_from_atom(self, atom: Atom) -> Optional[claripy.ast.bv.BV]:
+    def get_one_value_from_atom(self, atom: Atom) -> claripy.ast.bv.BV | None:
         r = self.get_value_from_atom(atom)
         if r is None:
             return None
         return r.one_value()
 
     @deprecated("get_concrete_value")
-    def get_concrete_value_from_atom(self, atom: Atom) -> Optional[int]:
+    def get_concrete_value_from_atom(self, atom: Atom) -> int | None:
         r = self.get_one_value_from_atom(atom)
         if r is None:
             return None
@@ -808,8 +809,8 @@ class LiveDefinitions:
         return r.concrete_value
 
     def get_values(
-        self, spec: Union[Atom, Definition[Atom], Iterable[Atom], Iterable[Definition[Atom]]]
-    ) -> Optional[MultiValues]:
+        self, spec: Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]]
+    ) -> MultiValues | None:
         if isinstance(spec, Definition):
             atom = spec.atom
         elif isinstance(spec, Atom):
@@ -868,9 +869,9 @@ class LiveDefinitions:
 
     def get_one_value(
         self,
-        spec: Union[Atom, Definition, Iterable[Atom], Iterable[Definition[Atom]]],
+        spec: Atom | Definition | Iterable[Atom] | Iterable[Definition[Atom]],
         strip_annotations: bool = False,
-    ) -> Optional[claripy.ast.bv.BV]:
+    ) -> claripy.ast.bv.BV | None:
         r = self.get_values(spec)
         if r is None:
             return None
@@ -878,21 +879,21 @@ class LiveDefinitions:
 
     @overload
     def get_concrete_value(
-        self, spec: Union[Atom, Definition[Atom], Iterable[Atom], Iterable[Definition[Atom]]], cast_to: Type[int] = ...
-    ) -> Optional[int]: ...
+        self, spec: Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]], cast_to: type[int] = ...
+    ) -> int | None: ...
 
     @overload
     def get_concrete_value(
         self,
-        spec: Union[Atom, Definition[Atom], Iterable[Atom], Iterable[Definition[Atom]]],
-        cast_to: Type[bytes] = ...,
-    ) -> Optional[bytes]: ...
+        spec: Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]],
+        cast_to: type[bytes] = ...,
+    ) -> bytes | None: ...
 
     def get_concrete_value(
         self,
-        spec: Union[Atom, Definition[Atom], Iterable[Atom], Iterable[Definition[Atom]]],
-        cast_to: Union[Type[int], Type[bytes]] = int,
-    ) -> Union[int, bytes, None]:
+        spec: Atom | Definition[Atom] | Iterable[Atom] | Iterable[Definition[Atom]],
+        cast_to: type[int] | type[bytes] = int,
+    ) -> int | bytes | None:
         r = self.get_one_value(spec, strip_annotations=True)
         if r is None:
             return None
@@ -903,7 +904,7 @@ class LiveDefinitions:
             return result.to_bytes(len(r) // 8, "big")
         return result
 
-    def add_register_use(self, reg_offset: int, size: int, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_register_use(self, reg_offset: int, size: int, code_loc: CodeLocation, expr: Any | None = None) -> None:
         # get all current definitions
         try:
             mvs: MultiValues = self.registers.load(reg_offset, size=size)
@@ -915,22 +916,22 @@ class LiveDefinitions:
                 for def_ in self.extract_defs(v):
                     self.add_register_use_by_def(def_, code_loc, expr=expr)
 
-    def add_register_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_register_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Any | None = None) -> None:
         self.register_uses.add_use(def_, code_loc, expr=expr)
         self.uses_by_codeloc[code_loc].add(def_)
 
-    def add_stack_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_stack_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Any | None = None) -> None:
         if not isinstance(atom.addr, SpOffset):
             raise TypeError("Atom %r is not a stack location atom." % atom)
 
         for current_def in self.get_definitions(atom):
             self.add_stack_use_by_def(current_def, code_loc, expr=expr)
 
-    def add_stack_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_stack_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Any | None = None) -> None:
         self.stack_uses.add_use(def_, code_loc, expr=expr)
         self.uses_by_codeloc[code_loc].add(def_)
 
-    def add_heap_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_heap_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Any | None = None) -> None:
         if not isinstance(atom.addr, HeapAddress):
             raise TypeError("Atom %r is not a heap location atom." % atom)
 
@@ -939,18 +940,18 @@ class LiveDefinitions:
         for current_def in current_defs:
             self.add_heap_use_by_def(current_def, code_loc, expr=expr)
 
-    def add_heap_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_heap_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Any | None = None) -> None:
         self.heap_uses.add_use(def_, code_loc, expr=expr)
         self.uses_by_codeloc[code_loc].add(def_)
 
-    def add_memory_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_memory_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Any | None = None) -> None:
         # get all current definitions
-        current_defs: Set[Definition] = self.get_definitions(atom)
+        current_defs: set[Definition] = self.get_definitions(atom)
 
         for current_def in current_defs:
             self.add_memory_use_by_def(current_def, code_loc, expr=expr)
 
-    def add_memory_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
+    def add_memory_use_by_def(self, def_: Definition, code_loc: CodeLocation, expr: Any | None = None) -> None:
         self.memory_uses.add_use(def_, code_loc, expr=expr)
         self.uses_by_codeloc[code_loc].add(def_)
 
@@ -977,18 +978,18 @@ class LiveDefinitions:
     @overload
     def deref(
         self,
-        pointer: Union[MultiValues, Atom, Definition, Iterable[Atom], Iterable[Definition]],
-        size: Union[int, DerefSize],
+        pointer: MultiValues | Atom | Definition | Iterable[Atom] | Iterable[Definition],
+        size: int | DerefSize,
         endness: archinfo.Endness = ...,
-    ) -> Set[MemoryLocation]: ...
+    ) -> set[MemoryLocation]: ...
 
     @overload
     def deref(
         self,
-        pointer: Union[int, claripy.ast.BV, HeapAddress, SpOffset],
-        size: Union[int, DerefSize],
+        pointer: int | claripy.ast.BV | HeapAddress | SpOffset,
+        size: int | DerefSize,
         endness: archinfo.Endness = ...,
-    ) -> Optional[MemoryLocation]: ...
+    ) -> MemoryLocation | None: ...
 
     def deref(self, pointer, size, endness=archinfo.Endness.BE):
         if isinstance(pointer, (Atom, Definition)):
@@ -1054,7 +1055,7 @@ class LiveDefinitions:
         return "heap_base" in addr.variables
 
     @staticmethod
-    def get_heap_offset(addr: claripy.ast.Base) -> Optional[int]:
+    def get_heap_offset(addr: claripy.ast.Base) -> int | None:
         if "heap_base" in addr.variables:
             if addr.op == "BVS":
                 return 0
@@ -1062,7 +1063,7 @@ class LiveDefinitions:
                 return addr.args[1].concrete_value
         return None
 
-    def heap_address(self, offset: Union[int, HeapAddress]) -> claripy.ast.BV:
+    def heap_address(self, offset: int | HeapAddress) -> claripy.ast.BV:
         if isinstance(offset, HeapAddress):
             if not isinstance(offset.value, int):
                 raise TypeError("TODO: what's this? contact @rhelmot")

angr/knowledge_plugins/key_definitions/liveness.py

@@ -1,4 +1,4 @@
-from typing import DefaultDict, Optional, List, Set, Tuple, Dict, TYPE_CHECKING
+from typing import DefaultDict, Optional, TYPE_CHECKING
 
 from collections import defaultdict
 from itertools import chain
@@ -13,11 +13,11 @@ if TYPE_CHECKING:
     from angr.code_location import CodeLocation
 
 
-LocationType = Tuple[int, Optional[int], Optional[int]]  # block addr, block ID, stmt ID
-LocationWithPosType = Tuple[
+LocationType = tuple[int, Optional[int], Optional[int]]  # block addr, block ID, stmt ID
+LocationWithPosType = tuple[
     int, Optional[int], Optional[int], ObservationPointType
 ]  # block addr, block ID, stmt ID, before/after
-BlockAddrType = Tuple[int, Optional[int]]  # block addr, block ID
+BlockAddrType = tuple[int, Optional[int]]  # block addr, block ID
 
 
 class Liveness:
@@ -26,14 +26,14 @@ class Liveness:
     """
 
     def __init__(self):
-        self.curr_live_defs: Set["Definition"] = set()
-        self.curr_loc: Optional[LocationType] = None
-        self.curr_block: Optional[BlockAddrType] = None
-        self.curr_stmt_idx: Optional[int] = None
-        self.blockstart_to_defs: DefaultDict[BlockAddrType, Set["Definition"]] = defaultdict(set)
-        self.blockend_to_defs: DefaultDict[BlockAddrType, Set["Definition"]] = defaultdict(set)
-        self.loc_to_killed_defs: DefaultDict[BlockAddrType, Dict[int, Set["Definition"]]] = defaultdict(dict)
-        self.loc_to_added_defs: DefaultDict[BlockAddrType, Dict[int, Set["Definition"]]] = defaultdict(dict)
+        self.curr_live_defs: set["Definition"] = set()
+        self.curr_loc: LocationType | None = None
+        self.curr_block: BlockAddrType | None = None
+        self.curr_stmt_idx: int | None = None
+        self.blockstart_to_defs: DefaultDict[BlockAddrType, set["Definition"]] = defaultdict(set)
+        self.blockend_to_defs: DefaultDict[BlockAddrType, set["Definition"]] = defaultdict(set)
+        self.loc_to_killed_defs: DefaultDict[BlockAddrType, dict[int, set["Definition"]]] = defaultdict(dict)
+        self.loc_to_added_defs: DefaultDict[BlockAddrType, dict[int, set["Definition"]]] = defaultdict(dict)
         self._node_max_stmt_id: DefaultDict[BlockAddrType, int] = defaultdict(int)
 
     def add_def(self, d: "Definition") -> None:
@@ -65,7 +65,7 @@ class Liveness:
         ):
             self._node_max_stmt_id[(code_loc.block_addr, code_loc.block_idx)] = code_loc.stmt_idx
 
-    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: List["CodeLocation"]) -> None:
+    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: list["CodeLocation"]) -> None:
         """
         Only support moving to a new block from one or more blocks.
         """
@@ -87,12 +87,12 @@ class Liveness:
         self.curr_loc = loc
         self.curr_stmt_idx = 0
 
-    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> Set["Definition"]:
+    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> set["Definition"]:
         return self.find_defs_at_raw(code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, op=op)
 
     def find_defs_at_raw(
-        self, block_addr: int, block_idx: Optional[int], stmt_idx: Optional[int], op: int = OP_BEFORE
-    ) -> Set["Definition"]:
+        self, block_addr: int, block_idx: int | None, stmt_idx: int | None, op: int = OP_BEFORE
+    ) -> set["Definition"]:
         block: BlockAddrType = block_addr, block_idx
         if block not in self.blockstart_to_defs:
             defs = set()

angr/knowledge_plugins/key_definitions/rd_model.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Tuple, Set, Union, Optional, TYPE_CHECKING, overload
+from typing import Union, TYPE_CHECKING, overload
 
 from .atoms import Atom, Register, MemoryLocation, SpOffset
 from .uses import Uses
@@ -17,12 +17,12 @@ class ReachingDefinitionsModel:
     Models the definitions, uses, and memory of a ReachingDefinitionState object
     """
 
-    def __init__(self, func_addr: Optional[int] = None, track_liveness: bool = True):
+    def __init__(self, func_addr: int | None = None, track_liveness: bool = True):
         self.func_addr = func_addr  # do not use. only for pretty-printing
-        self.observed_results: Dict[
-            Tuple[str, Union[int, Tuple[int, int], Tuple[int, int, int]], ObservationPointType], LiveDefinitions
+        self.observed_results: dict[
+            tuple[str, int | tuple[int, int] | tuple[int, int, int], ObservationPointType], LiveDefinitions
         ] = {}
-        self.all_definitions: Set["Definition"] = set()
+        self.all_definitions: set["Definition"] = set()
         self.all_uses = Uses()
         self.liveness = Liveness() if track_liveness else None
 
@@ -44,7 +44,7 @@ class ReachingDefinitionsModel:
         if self.liveness is not None:
             self.liveness.at_new_stmt(codeloc)
 
-    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: List["CodeLocation"]) -> None:
+    def at_new_block(self, code_loc: "CodeLocation", pred_codelocs: list["CodeLocation"]) -> None:
         if self.liveness is not None:
             self.liveness.at_new_block(code_loc, pred_codelocs)
 
@@ -52,10 +52,10 @@ class ReachingDefinitionsModel:
         if self.liveness is not None:
             self.liveness.make_liveness_snapshot()
 
-    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> Set["Definition"]:
+    def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> set["Definition"]:
         return self.liveness.find_defs_at(code_loc, op=op)
 
-    def get_defs(self, atom: Atom, code_loc: "CodeLocation", op: int) -> Set["Definition"]:
+    def get_defs(self, atom: Atom, code_loc: "CodeLocation", op: int) -> set["Definition"]:
         all_defs = self.liveness.find_defs_at(code_loc, op=op)
         defs = None
         if isinstance(atom, Register):
@@ -117,7 +117,7 @@ class ReachingDefinitionsModel:
 
     def get_observation_by_insn(
         self, ins_addr: Union[int, "CodeLocation"], kind: ObservationPointType
-    ) -> Optional[LiveDefinitions]:
+    ) -> LiveDefinitions | None:
         if isinstance(ins_addr, int):
             return self.observed_results.get(("insn", ins_addr, kind), None)
         elif ins_addr.ins_addr is None:
@@ -125,8 +125,8 @@ class ReachingDefinitionsModel:
         return self.observed_results.get(("insn", ins_addr.ins_addr, kind))
 
     def get_observation_by_node(
-        self, node_addr: Union[int, "CodeLocation"], kind: ObservationPointType, node_idx: Optional[int] = None
-    ) -> Optional[LiveDefinitions]:
+        self, node_addr: Union[int, "CodeLocation"], kind: ObservationPointType, node_idx: int | None = None
+    ) -> LiveDefinitions | None:
         if isinstance(node_addr, int):
             key = ("node", node_addr, kind) if node_idx is None else ("node", (node_addr, node_idx), kind)
             return self.observed_results.get(key, None)
@@ -141,11 +141,11 @@ class ReachingDefinitionsModel:
     @overload
     def get_observation_by_stmt(
         self, codeloc: "CodeLocation", kind: ObservationPointType
-    ) -> Optional[LiveDefinitions]: ...
+    ) -> LiveDefinitions | None: ...
 
     @overload
     def get_observation_by_stmt(
-        self, node_addr: int, stmt_idx: int, kind: ObservationPointType, *, block_idx: Optional[int] = None
+        self, node_addr: int, stmt_idx: int, kind: ObservationPointType, *, block_idx: int | None = None
     ): ...
 
     def get_observation_by_stmt(self, arg1, arg2, arg3=None, *, block_idx=None):
@@ -166,8 +166,8 @@ class ReachingDefinitionsModel:
         self,
         node_addr: int,
         stmt_idx: int,
-        src_node_idx: Optional[int] = None,
-    ) -> Optional[LiveDefinitions]:
+        src_node_idx: int | None = None,
+    ) -> LiveDefinitions | None:
         key = (
             ("exit", (node_addr, stmt_idx), ObservationPointType.OP_AFTER)
             if src_node_idx is None

angr/knowledge_plugins/key_definitions/uses.py

@@ -1,5 +1,5 @@
 # pylint:disable=unsubscriptable-object
-from typing import Set, Optional, Tuple, Any, Union, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 from ...utils.cowdict import DefaultChainMapCOW
 from ...code_location import CodeLocation
@@ -17,21 +17,21 @@ class Uses:
 
     def __init__(
         self,
-        uses_by_definition: Optional[DefaultChainMapCOW] = None,
-        uses_by_location: Optional[DefaultChainMapCOW] = None,
+        uses_by_definition: DefaultChainMapCOW | None = None,
+        uses_by_location: DefaultChainMapCOW | None = None,
     ):
-        self._uses_by_definition: DefaultChainMapCOW["Definition", Set[Tuple[CodeLocation, Optional[Any]]]] = (
+        self._uses_by_definition: DefaultChainMapCOW["Definition", set[tuple[CodeLocation, Any | None]]] = (
             DefaultChainMapCOW(default_factory=set, collapse_threshold=25)
             if uses_by_definition is None
             else uses_by_definition
         )
-        self._uses_by_location: DefaultChainMapCOW[CodeLocation, Set[Tuple["Definition", Optional[Any]]]] = (
+        self._uses_by_location: DefaultChainMapCOW[CodeLocation, set[tuple["Definition", Any | None]]] = (
             DefaultChainMapCOW(default_factory=set, collapse_threshold=25)
             if uses_by_location is None
             else uses_by_location
         )
 
-    def add_use(self, definition: "Definition", codeloc: CodeLocation, expr: Optional[Any] = None):
+    def add_use(self, definition: "Definition", codeloc: CodeLocation, expr: Any | None = None):
         """
         Add a use for a given definition.
 
@@ -44,7 +44,7 @@ class Uses:
         self._uses_by_location = self._uses_by_location.clean()
         self._uses_by_location[codeloc].add((definition, expr))
 
-    def get_uses(self, definition: "Definition") -> Set[CodeLocation]:
+    def get_uses(self, definition: "Definition") -> set[CodeLocation]:
         """
         Retrieve the uses of a given definition.
 
@@ -52,7 +52,7 @@ class Uses:
         """
         return {codeloc for codeloc, _ in self._uses_by_definition.get(definition, set())}
 
-    def get_uses_with_expr(self, definition: "Definition") -> Set[Tuple[CodeLocation, Optional[Any]]]:
+    def get_uses_with_expr(self, definition: "Definition") -> set[tuple[CodeLocation, Any | None]]:
         """
         Retrieve the uses and the corresponding expressions of a given definition.
 
@@ -60,7 +60,7 @@ class Uses:
         """
         return self._uses_by_definition.get(definition, set())
 
-    def remove_use(self, definition: "Definition", codeloc: "CodeLocation", expr: Optional[Any] = None) -> None:
+    def remove_use(self, definition: "Definition", codeloc: "CodeLocation", expr: Any | None = None) -> None:
         """
         Remove one use of a given definition.
 
@@ -105,7 +105,7 @@ class Uses:
 
     def get_uses_by_location(
         self, codeloc: CodeLocation, exprs: bool = False
-    ) -> Union[Set["Definition"], Set[Tuple["Definition", Optional[Any]]]]:
+    ) -> set["Definition"] | set[tuple["Definition", Any | None]]:
         """
         Retrieve all definitions that are used at a given location.
 
@@ -118,7 +118,7 @@ class Uses:
 
     def get_uses_by_insaddr(
         self, ins_addr: int, exprs: bool = False
-    ) -> Union[Set["Definition"], Set[Tuple["Definition", Optional[Any]]]]:
+    ) -> set["Definition"] | set[tuple["Definition", Any | None]]:
         """
         Retrieve all definitions that are used at a given location specified by the instruction address.
 

angr/knowledge_plugins/patches.py

@@ -1,5 +1,3 @@
-from typing import Optional, List, Dict
-
 from cle.address_translator import AddressTranslator
 from sortedcontainers import SortedDict
 
@@ -8,7 +6,7 @@ from .plugin import KnowledgeBasePlugin
 
 # TODO: Serializable
 class Patch:
-    def __init__(self, addr, new_bytes, comment: Optional[str] = None):
+    def __init__(self, addr, new_bytes, comment: str | None = None):
         self.addr = addr
         self.new_bytes = new_bytes
         self.comment = comment
@@ -29,10 +27,10 @@ class PatchManager(KnowledgeBasePlugin):
     def __init__(self, kb):
         super().__init__(kb=kb)
 
-        self._patches: Dict[int, Patch] = SortedDict()
+        self._patches: dict[int, Patch] = SortedDict()
         self._patched_entry_state = None
 
-    def add_patch(self, addr, new_bytes, comment: Optional[str] = None):
+    def add_patch(self, addr, new_bytes, comment: str | None = None):
         self._patches[addr] = Patch(addr, new_bytes, comment=comment)
         self._patched_entry_state = None
 
@@ -93,9 +91,7 @@ class PatchManager(KnowledgeBasePlugin):
     def overlap(a0, a1, b0, b1):
         return a0 <= b0 < a1 or a0 <= b1 < a1 or b0 <= a0 < b1
 
-    def apply_patches_to_binary(
-        self, binary_bytes: Optional[bytes] = None, patches: Optional[List[Patch]] = None
-    ) -> bytes:
+    def apply_patches_to_binary(self, binary_bytes: bytes | None = None, patches: list[Patch] | None = None) -> bytes:
         if patches is None:
             patches = sorted(list(self._patches.values()), key=lambda x: x.addr)