angr 9.2.117__py3-none-manylinux2014_aarch64.whl → 9.2.118__py3-none-manylinux2014_aarch64.whl

angr/analyses/reaching_definitions/function_handler.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING, cast, Literal
 from collections.abc import Iterable, Callable
 from dataclasses import dataclass, field
@@ -29,7 +30,7 @@ if TYPE_CHECKING:
 l = logging.getLogger(__name__)
 
 
-def get_exit_livedefinitions(func: Function, rda_model: "ReachingDefinitionsModel"):
+def get_exit_livedefinitions(func: Function, rda_model: ReachingDefinitionsModel):
     """
     Get LiveDefinitions at all exits of a function, merge them, and return.
     """
@@ -97,7 +98,7 @@ class FunctionCallData:
     ret_atoms: set[Atom] | None = None
     redefine_locals: bool = True
     visited_blocks: set[int] | None = None
-    effects: list[FunctionEffect] = field(default_factory=lambda: [])
+    effects: list[FunctionEffect] = field(default_factory=list)
     ret_values: MultiValues | None = None
     ret_values_deps: set[Definition] | None = None
     caller_will_handle_single_ret: bool = False
@@ -187,7 +188,7 @@ class FunctionCallData:
             )
 
     def reset_prototype(
-        self, prototype: SimTypeFunction, state: "ReachingDefinitionsState", soft_reset: bool = False
+        self, prototype: SimTypeFunction, state: ReachingDefinitionsState, soft_reset: bool = False
     ) -> set[Atom]:
         self.prototype = prototype.with_arch(state.arch)
         if not soft_reset:
@@ -205,9 +206,13 @@ class FunctionCallData:
                 args_atoms_from_values |= atoms_set
         elif self.args_atoms is None and self.cc is not None and self.prototype is not None:
             self.args_atoms = FunctionHandler.c_args_as_atoms(state, self.cc, self.prototype)
-        if self.ret_atoms is None and self.cc is not None and self.prototype is not None:
-            if self.prototype.returnty is not None:
-                self.ret_atoms = FunctionHandler.c_return_as_atoms(state, self.cc, self.prototype)
+        if (
+            self.ret_atoms is None
+            and self.cc is not None
+            and self.prototype is not None
+            and self.prototype.returnty is not None
+        ):
+            self.ret_atoms = FunctionHandler.c_return_as_atoms(state, self.cc, self.prototype)
         return args_atoms_from_values
 
 
@@ -232,23 +237,23 @@ class FunctionCallDataUnwrapped(FunctionCallData):
         d = dict(inner.__dict__)
         annotations = type(self).__annotations__  # pylint: disable=no-member
         for k, v in d.items():
-            assert v is not None or k not in annotations, (
-                "Failed to unwrap field %s - this function is more complicated than you're ready for!" % k
-            )
+            assert (
+                v is not None or k not in annotations
+            ), f"Failed to unwrap field {k} - this function is more complicated than you're ready for!"
             assert v is not None, "Members of FunctionCallDataUnwrapped may not be None"
         super().__init__(**d)
 
     @staticmethod
     @wraps
     def decorate(
-        f: Callable[["FunctionHandler", "ReachingDefinitionsState", "FunctionCallDataUnwrapped"], None]
-    ) -> Callable[["FunctionHandler", "ReachingDefinitionsState", FunctionCallData], None]:
+        f: Callable[[FunctionHandler, ReachingDefinitionsState, FunctionCallDataUnwrapped], None]
+    ) -> Callable[[FunctionHandler, ReachingDefinitionsState, FunctionCallData], None]:
         """
         Decorate a function handler method with this to make it take a FunctionCallDataUnwrapped instead of a
         FunctionCallData.
         """
 
-        def inner(self: "FunctionHandler", state: "ReachingDefinitionsState", data: FunctionCallData):
+        def inner(self: FunctionHandler, state: ReachingDefinitionsState, data: FunctionCallData):
             f(self, state, FunctionCallDataUnwrapped(data))
 
         return inner
@@ -264,7 +269,7 @@ class FunctionHandler:
     A mechanism for summarizing a function call's effect on a program for ReachingDefinitionsAnalysis.
     """
 
-    def __init__(self, interfunction_level: int = 0, extra_impls: Iterable["FunctionHandler"] | None = None):
+    def __init__(self, interfunction_level: int = 0, extra_impls: Iterable[FunctionHandler] | None = None):
         self.interfunction_level: int = interfunction_level
 
         if extra_impls is not None:
@@ -273,7 +278,7 @@ class FunctionHandler:
                     if name.startswith("handle_impl_"):
                         setattr(self, name, _mk_wrapper(func, self))
 
-    def hook(self, analysis: "ReachingDefinitionsAnalysis") -> "FunctionHandler":
+    def hook(self, analysis: ReachingDefinitionsAnalysis) -> FunctionHandler:
         """
         Attach this instance of the function handler to an instance of RDA.
         """
@@ -287,22 +292,16 @@ class FunctionHandler:
         """
         if isinstance(target, MultiValues):
             target_bv = target.one_value()
-            if target_bv is not None and target_bv.op == "BVV":
-                target_int = target_bv.args[0]
-            else:
-                target_int = None
+            target_int = target_bv.args[0] if target_bv is not None and target_bv.op == "BVV" else None
         else:
             target_int = target
         if callsite.context is None:
             return CodeLocation(target_int, stmt_idx=None, context=None)
-        elif type(callsite.context) is tuple and callsite_func_addr is not None:
-            return CodeLocation(target_int, stmt_idx=None, context=(callsite.block_addr,) + callsite.context)
-        else:
-            raise TypeError(
-                "Please implement FunctionHandler.make_function_codeloc for your special context sensitivity"
-            )
+        if type(callsite.context) is tuple and callsite_func_addr is not None:
+            return CodeLocation(target_int, stmt_idx=None, context=(callsite.block_addr, *callsite.context))
+        raise TypeError("Please implement FunctionHandler.make_function_codeloc for your special context sensitivity")
 
-    def handle_function(self, state: "ReachingDefinitionsState", data: FunctionCallData):
+    def handle_function(self, state: ReachingDefinitionsState, data: FunctionCallData):
         """
         The main entry point for the function handler. Called with a RDA state and a FunctionCallData, it is expected
         to update the state and the data as per the contracts described on FunctionCallData.
@@ -485,7 +484,7 @@ class FunctionHandler:
         # move the current codeloc back to the callsite
         state.move_codelocs(data.callsite_codeloc)
 
-    def handle_generic_function(self, state: "ReachingDefinitionsState", data: FunctionCallData):
+    def handle_generic_function(self, state: ReachingDefinitionsState, data: FunctionCallData):
         assert data.cc is not None
         assert data.prototype is not None
         if data.prototype.returnty is not None:
@@ -511,10 +510,10 @@ class FunctionHandler:
             for atom in data.ret_atoms:
                 data.depends(atom, *sources, apply_at_callsite=True)
 
-    def handle_indirect_function(self, state: "ReachingDefinitionsState", data: FunctionCallData) -> None:
+    def handle_indirect_function(self, state: ReachingDefinitionsState, data: FunctionCallData) -> None:
         self.handle_generic_function(state, data)
 
-    def handle_local_function(self, state: "ReachingDefinitionsState", data: FunctionCallData) -> None:
+    def handle_local_function(self, state: ReachingDefinitionsState, data: FunctionCallData) -> None:
         if self.interfunction_level > 0 and data.function is not None and state.analysis is not None:
             self.interfunction_level -= 1
             try:
@@ -524,10 +523,10 @@ class FunctionHandler:
         else:
             self.handle_generic_function(state, data)
 
-    def handle_external_function(self, state: "ReachingDefinitionsState", data: FunctionCallData) -> None:
+    def handle_external_function(self, state: ReachingDefinitionsState, data: FunctionCallData) -> None:
         self.handle_generic_function(state, data)
 
-    def recurse_analysis(self, state: "ReachingDefinitionsState", data: FunctionCallData) -> None:
+    def recurse_analysis(self, state: ReachingDefinitionsState, data: FunctionCallData) -> None:
         """
         Precondition: ``data.function`` MUST NOT BE NONE in order to call this method.
         """
@@ -567,7 +566,7 @@ class FunctionHandler:
         data.retaddr_popped = True
 
     @staticmethod
-    def c_args_as_atoms(state: "ReachingDefinitionsState", cc: SimCC, prototype: SimTypeFunction) -> list[set[Atom]]:
+    def c_args_as_atoms(state: ReachingDefinitionsState, cc: SimCC, prototype: SimTypeFunction) -> list[set[Atom]]:
         if not prototype.variadic:
             sp_value = state.get_one_value(Register(state.arch.sp_offset, state.arch.bytes), strip_annotations=True)
             sp = state.get_stack_offset(sp_value) if sp_value is not None else None
@@ -590,7 +589,7 @@ class FunctionHandler:
         return [{Register(*state.arch.registers[arg_name], arch=state.arch)} for arg_name in cc.ARG_REGS]
 
     @staticmethod
-    def c_return_as_atoms(state: "ReachingDefinitionsState", cc: SimCC, prototype: SimTypeFunction) -> set[Atom]:
+    def c_return_as_atoms(state: ReachingDefinitionsState, cc: SimCC, prototype: SimTypeFunction) -> set[Atom]:
         if prototype.returnty is not None and not isinstance(prototype.returnty, SimTypeBottom):
             retval = cc.return_val(prototype.returnty)
             if retval is not None:
@@ -601,7 +600,7 @@ class FunctionHandler:
         return set()
 
     @staticmethod
-    def caller_saved_regs_as_atoms(state: "ReachingDefinitionsState", cc: SimCC) -> set[Register]:
+    def caller_saved_regs_as_atoms(state: ReachingDefinitionsState, cc: SimCC) -> set[Register]:
         return (
             {Register(*state.arch.registers[reg], arch=state.arch) for reg in cc.CALLER_SAVED_REGS}
             if cc.CALLER_SAVED_REGS is not None

angr/analyses/reaching_definitions/function_handler_library/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .stdlib import LibcStdlibHandlers, EnvironAtom, SystemAtom, ExecveAtom
 from .stdio import LibcStdioHandlers, StdoutAtom, StdinAtom
 from .unistd import LibcUnistdHandlers

angr/analyses/reaching_definitions/function_handler_library/stdio.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import re
 import random
 import logging
@@ -217,9 +218,8 @@ def handle_printf(
             _l.warning("Unimplemented printf format string %s", fmt)
             buf_atoms = set()
             buf_data = None
-        if result is not None:
-            if buf_data is not None:
-                result = result.concat(buf_data)
+        if result is not None and buf_data is not None:
+            result = result.concat(buf_data)
         source_atoms.update(buf_atoms)
     if result is not None:
         result = result.concat(b"\0")
@@ -250,9 +250,7 @@ def handle_scanf(
         if fmt == "%s":
             buf_atom = state.deref(atom, 1)
             buf_data = b"\0"
-        elif fmt == "%u":
-            buf_atom = state.deref(atom, 4, state.arch.memory_endness)
-        elif fmt == "%d":
+        elif fmt == "%u" or fmt == "%d":
             buf_atom = state.deref(atom, 4, state.arch.memory_endness)
         elif fmt == "%c":
             buf_atom = state.deref(atom, 1, state.arch.memory_endness)

angr/analyses/reaching_definitions/function_handler_library/stdlib.py

@@ -23,8 +23,7 @@ class EnvironAtom(Atom):
     def _identity(self):
         if self.name is not None:
             return (self.name,)
-        else:
-            return ()
+        return ()
 
     def __repr__(self):
         return f'<EnvironAtom {self.name if self.name is not None else "(dynamic)"}>'

angr/analyses/reaching_definitions/function_handler_library/string.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import archinfo
 from angr.analyses.reaching_definitions.function_handler import FunctionCallDataUnwrapped, FunctionHandler
 from angr.analyses.reaching_definitions.rd_state import ReachingDefinitionsState
@@ -57,10 +58,7 @@ class LibcStringHandlers(FunctionHandler):
     def handle_impl_strdup(self, state: ReachingDefinitionsState, data: FunctionCallDataUnwrapped):
         src_atom = state.deref(data.args_atoms[1], DerefSize.NULL_TERMINATE)
         src_str = state.get_values(src_atom)
-        if src_str is not None:
-            malloc_size = len(src_str) // 8
-        else:
-            malloc_size = 1
+        malloc_size = len(src_str) // 8 if src_str is not None else 1
         heap_ptr = state.heap_allocator.allocate(malloc_size)
         dst_atom = state.deref(heap_ptr, malloc_size)
         data.depends(dst_atom, src_atom, value=src_str)

angr/analyses/reaching_definitions/function_handler_library/unistd.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from angr.analyses.reaching_definitions.function_handler import FunctionCallDataUnwrapped, FunctionHandler
 from angr.analyses.reaching_definitions.function_handler_library.stdio import StdinAtom, StdoutAtom
 from angr.analyses.reaching_definitions.rd_state import ReachingDefinitionsState

angr/analyses/reaching_definitions/heap_allocator.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 
@@ -15,7 +16,7 @@ class HeapAllocator:
     - Take care of the size not to screw potential pointer arithmetic (avoid overlapping segments).
 
     The content of the heap itself is modeled using a <KeyedRegion> attribute in the <LiveDefinitions> state;
-    This class serves to generate consistent heap addresses to be used by the aforementionned.
+    This class serves to generate consistent heap addresses to be used by the aforementioned.
 
     *Note:* This has **NOT** been made to help detect heap vulnerabilities.
     """
@@ -30,10 +31,10 @@ class HeapAllocator:
 
     def allocate(self, size: int | UnknownSize) -> HeapAddress:
         """
-        Gives an address for a new memory chunck of <size> bytes.
+        Gives an address for a new memory chunk of <size> bytes.
 
-        :param size: The requested size for the chunck, in number of bytes.
-        :return: The address of the chunck.
+        :param size: The requested size for the chunk, in number of bytes.
+        :return: The address of the chunk.
         """
         address = self._next_heap_address
 
@@ -46,9 +47,9 @@ class HeapAllocator:
 
     def free(self, address: Undefined | HeapAddress):
         """
-        Mark the chunck pointed by <address> as freed.
+        Mark the chunk pointed by <address> as freed.
 
-        :param address: The address of the chunck to free.
+        :param address: The address of the chunk to free.
         """
 
         if isinstance(address, Undefined):

angr/analyses/reaching_definitions/rd_initializer.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
@@ -38,7 +39,7 @@ class RDAStateInitializer:
         self.project = project
 
     def initialize_function_state(
-        self, state: "ReachingDefinitionsState", cc: SimCC | None, func_addr: int, rtoc_value: int | None = None
+        self, state: ReachingDefinitionsState, cc: SimCC | None, func_addr: int, rtoc_value: int | None = None
     ) -> None:
         """
         This is the entry point to the state initialization logic.
@@ -68,7 +69,7 @@ class RDAStateInitializer:
 
     def initialize_all_function_arguments(
         self,
-        state: "ReachingDefinitionsState",
+        state: ReachingDefinitionsState,
         func_addr: int,
         ex_loc: ExternalCodeLocation,
         cc: SimCC | None,
@@ -92,7 +93,7 @@ class RDAStateInitializer:
 
     def initialize_one_function_argument(
         self,
-        state: "ReachingDefinitionsState",
+        state: ReachingDefinitionsState,
         func_addr: int,
         ex_loc: ExternalCodeLocation,
         argument_location: SimFunctionArgument,
@@ -117,10 +118,10 @@ class RDAStateInitializer:
         elif isinstance(argument_location, SimStackArg):
             self._initialize_function_argument_stack(state, func_addr, ex_loc, argument_location)
         else:
-            raise TypeError("Unsupported parameter type %s." % type(argument_location).__name__)
+            raise TypeError(f"Unsupported parameter type {type(argument_location).__name__}.")
 
     def initialize_stack_pointer(
-        self, state: "ReachingDefinitionsState", _func_addr: int, ex_loc: ExternalCodeLocation
+        self, state: ReachingDefinitionsState, _func_addr: int, ex_loc: ExternalCodeLocation
     ) -> None:
         # initialize stack pointer
         sp_atom = Register(self.arch.sp_offset, self.arch.bytes)
@@ -130,7 +131,7 @@ class RDAStateInitializer:
 
     def initialize_architectural_state(
         self,
-        state: "ReachingDefinitionsState",
+        state: ReachingDefinitionsState,
         func_addr: int,
         ex_loc: ExternalCodeLocation,
         rtoc_value: int | None = None,
@@ -173,21 +174,24 @@ class RDAStateInitializer:
             state.registers.store(t9_offset, t9)
 
         # project-specific initialization
-        if self.project is not None:
-            if self.project.simos is not None and self.project.simos.function_initial_registers:
-                for reg_name, reg_value in self.project.simos.function_initial_registers.items():
-                    reg_offset = self.arch.registers[reg_name][0]
-                    reg_atom = Register(reg_offset, self.arch.registers[reg_name][1])
-                    reg_def = Definition(reg_atom, ex_loc, tags={InitialValueTag()})
-                    state.all_definitions.add(reg_def)
-                    if state.analysis is not None:
-                        state.analysis.model.add_def(reg_def)
-                    reg = state.annotate_with_def(claripy.BVV(reg_value, self.arch.registers[reg_name][1]), reg_def)
-                    state.registers.store(reg_offset, reg)
+        if (
+            self.project is not None
+            and self.project.simos is not None
+            and self.project.simos.function_initial_registers
+        ):
+            for reg_name, reg_value in self.project.simos.function_initial_registers.items():
+                reg_offset = self.arch.registers[reg_name][0]
+                reg_atom = Register(reg_offset, self.arch.registers[reg_name][1])
+                reg_def = Definition(reg_atom, ex_loc, tags={InitialValueTag()})
+                state.all_definitions.add(reg_def)
+                if state.analysis is not None:
+                    state.analysis.model.add_def(reg_def)
+                reg = state.annotate_with_def(claripy.BVV(reg_value, self.arch.registers[reg_name][1]), reg_def)
+                state.registers.store(reg_offset, reg)
 
     def _initialize_function_argument_register(
         self,
-        state: "ReachingDefinitionsState",
+        state: ReachingDefinitionsState,
         func_addr: int,
         ex_loc: ExternalCodeLocation,
         arg: SimRegArg,
@@ -206,7 +210,7 @@ class RDAStateInitializer:
         state.registers.store(reg_offset, reg)
 
     def _initialize_function_argument_stack(
-        self, state: "ReachingDefinitionsState", func_addr: int, ex_loc: ExternalCodeLocation, arg: SimStackArg
+        self, state: ReachingDefinitionsState, func_addr: int, ex_loc: ExternalCodeLocation, arg: SimStackArg
     ):
         ml_atom = MemoryLocation(SpOffset(self.arch.bits, arg.stack_offset), arg.size)
         ml_def = Definition(ml_atom, ex_loc, tags={ParameterTag(function=func_addr)})
@@ -221,15 +225,13 @@ class RDAStateInitializer:
     def _generate_call_string(subject: Subject, current_address: int) -> tuple[int, ...] | None:
         if isinstance(subject.content, Function):
             return (subject.content.addr,)
-        elif isinstance(subject.content, CallTrace):
+        if isinstance(subject.content, CallTrace):
             if any(current_address == x.caller_func_addr for x in subject.content.callsites):
                 callsites = iter(reversed([x.caller_func_addr for x in subject.content.callsites]))
                 for call_addr in callsites:
                     if current_address == call_addr:
                         break
                 return tuple(callsites)
-            else:
-                return tuple(x.caller_func_addr for x in subject.content.callsites)
-        else:
-            l.warning("Subject with unknown content-type")
-            return None
+            return tuple(x.caller_func_addr for x in subject.content.callsites)
+        l.warning("Subject with unknown content-type")
+        return None

angr/analyses/reaching_definitions/rd_state.py

@@ -1,4 +1,5 @@
-from typing import Optional, Any, TYPE_CHECKING, overload
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING, overload
 from collections.abc import Iterable, Iterator
 import logging
 
@@ -84,7 +85,7 @@ class ReachingDefinitionsState:
         subject: Subject,
         track_tmps: bool = False,
         track_consts: bool = False,
-        analysis: Optional["ReachingDefinitionsAnalysis"] = None,
+        analysis: ReachingDefinitionsAnalysis | None = None,
         rtoc_value=None,
         live_definitions: LiveDefinitions | None = None,
         canonical_size: int = 8,
@@ -92,7 +93,7 @@ class ReachingDefinitionsState:
         environment: Environment = None,
         sp_adjusted: bool = False,
         all_definitions: set[Definition[A]] | None = None,
-        initializer: Optional["RDAStateInitializer"] = None,
+        initializer: RDAStateInitializer | None = None,
         element_limit: int = 5,
         merge_into_tops: bool = True,
     ):
@@ -179,10 +180,9 @@ class ReachingDefinitionsState:
     def _initial_stack_pointer(self):
         if self.arch.bits == 32:
             return claripy.BVS("stack_base", 32, explicit_name=True)
-        elif self.arch.bits == 64:
+        if self.arch.bits == 64:
             return claripy.BVS("stack_base", 64, explicit_name=True)
-        else:
-            raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
+        raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
 
     def _to_signed(self, n):
         if n >= 2 ** (self.arch.bits - 1):
@@ -276,8 +276,8 @@ class ReachingDefinitionsState:
         return self.analysis.dep_graph
 
     def __repr__(self):
-        ctnt = "RDState-%r" % (self.live_definitions)
-        return "{%s}" % ctnt
+        ctnt = f"RDState-{self.live_definitions!r}"
+        return f"{{{ctnt}}}"
 
     def _set_initialization_values(
         self,
@@ -306,8 +306,8 @@ class ReachingDefinitionsState:
 
         return self
 
-    def copy(self, discard_tmpdefs=False) -> "ReachingDefinitionsState":
-        rd = ReachingDefinitionsState(
+    def copy(self, discard_tmpdefs=False) -> ReachingDefinitionsState:
+        return ReachingDefinitionsState(
             self.codeloc,
             self.arch,
             self._subject,
@@ -323,18 +323,16 @@ class ReachingDefinitionsState:
             element_limit=self._element_limit,
         )
 
-        return rd
-
-    def merge(self, *others) -> tuple["ReachingDefinitionsState", bool]:
+    def merge(self, *others) -> tuple[ReachingDefinitionsState, bool]:
         state = self.copy()
-        others: Iterable["ReachingDefinitionsState"]
+        others: Iterable[ReachingDefinitionsState]
 
         state.live_definitions, merged_0 = state.live_definitions.merge(*[other.live_definitions for other in others])
         state._environment, merged_1 = state.environment.merge(*[other.environment for other in others])
 
         return state, merged_0 or merged_1
 
-    def compare(self, other: "ReachingDefinitionsState") -> bool:
+    def compare(self, other: ReachingDefinitionsState) -> bool:
         r0 = self.live_definitions.compare(other.live_definitions)
         r1 = self.environment.compare(other.environment)
 
@@ -362,7 +360,7 @@ class ReachingDefinitionsState:
         atom: Atom,
         data: MultiValues,
         dummy=False,
-        tags: set[Tag] = None,
+        tags: set[Tag] | None = None,
         endness=None,  # XXX destroy
         annotated: bool = False,
         uses: set[Definition[A]] | None = None,

angr/analyses/reaching_definitions/reaching_definitions.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
 import logging
-from typing import Optional, DefaultDict, Any, Union, TYPE_CHECKING
+from typing import Any
 from collections.abc import Iterable
 from collections import defaultdict
 
@@ -13,7 +14,7 @@ from ...codenode import CodeNode
 from ...engines.light import SimEngineLight
 from ...knowledge_plugins.functions import Function
 from ...knowledge_plugins.key_definitions import ReachingDefinitionsModel, LiveDefinitions
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER, ObservationPointType
+from ...knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER, ObservationPointType, ObservationPoint
 from ...code_location import CodeLocation, ExternalCodeLocation
 from ...misc.ux import deprecated
 from ..forward_analysis.visitors.graph import NodeType
@@ -25,13 +26,8 @@ from .rd_initializer import RDAStateInitializer
 from .subject import Subject, SubjectType
 from .function_handler import FunctionHandler, FunctionCallRelationships
 from .dep_graph import DepGraph
+import contextlib
 
-if TYPE_CHECKING:
-    from typing import Literal
-
-    ObservationPoint = tuple[
-        Literal["insn", "node", "stmt", "exit"], Union[int, tuple[int, int], tuple[int, int, int]], ObservationPointType
-    ]
 
 l = logging.getLogger(name=__name__)
 
@@ -59,12 +55,12 @@ class ReachingDefinitionsAnalysis(
         max_iterations=30,
         track_tmps=False,
         track_consts=True,
-        observation_points: "Iterable[ObservationPoint]" = None,
+        observation_points: Iterable[ObservationPoint] | None = None,
         init_state: ReachingDefinitionsState = None,
         init_context=None,
-        state_initializer: Optional["RDAStateInitializer"] = None,
+        state_initializer: RDAStateInitializer | None = None,
         cc=None,
-        function_handler: "Optional[FunctionHandler]" = None,
+        function_handler: FunctionHandler | None = None,
         observe_all=False,
         visited_blocks=None,
         dep_graph: DepGraph | bool | None = True,
@@ -172,7 +168,7 @@ class ReachingDefinitionsAnalysis(
         if self._observation_points and any(type(op) is not tuple for op in self._observation_points):
             raise ValueError('"observation_points" must be tuples.')
 
-        self._node_iterations: DefaultDict[int, int] = defaultdict(int)
+        self._node_iterations: defaultdict[int, int] = defaultdict(int)
 
         self.model: ReachingDefinitionsModel = ReachingDefinitionsModel(
             func_addr=self.subject.content.addr if isinstance(self.subject.content, Function) else None,
@@ -185,10 +181,8 @@ class ReachingDefinitionsAnalysis(
             the_func = self.subject.content
         else:
             if self._func_addr is not None:
-                try:
+                with contextlib.suppress(KeyError):
                     the_func = self.kb.functions.get_by_addr(self._func_addr)
-                except KeyError:
-                    pass
         if the_func is not None:
             bp_as_gpr = the_func.info.get("bp_as_gpr", False)
 
@@ -256,8 +250,8 @@ class ReachingDefinitionsAnalysis(
         key = "insn", ins_addr, op_type
         if key not in self.observed_results:
             raise KeyError(
-                "Reaching definitions are not available at observation point %s. "
-                "Did you specify that observation point?" % str(key)
+                f"Reaching definitions are not available at observation point {key!s}. "
+                "Did you specify that observation point?"
             )
 
         return self.observed_results[key]
@@ -266,8 +260,8 @@ class ReachingDefinitionsAnalysis(
         key = "node", node_addr, op_type
         if key not in self.observed_results:
             raise KeyError(
-                "Reaching definitions are not available at observation point %s. "
-                "Did you specify that observation point?" % str(key)
+                f"Reaching definitions are not available at observation point {key!s}. "
+                "Did you specify that observation point?"
             )
 
         return self.observed_results[key]
@@ -468,19 +462,18 @@ class ReachingDefinitionsAnalysis(
     def _initial_abstract_state(self, node) -> ReachingDefinitionsState:
         if self._init_state is not None:
             return self._init_state
-        else:
-            return ReachingDefinitionsState(
-                CodeLocation(node.addr, stmt_idx=0, ins_addr=node.addr, context=self._init_context),
-                self.project.arch,
-                self.subject,
-                track_tmps=self._track_tmps,
-                track_consts=self._track_consts,
-                analysis=self,
-                canonical_size=self._canonical_size,
-                initializer=self._state_initializer,
-                element_limit=self._element_limit,
-                merge_into_tops=self._merge_into_tops,
-            )
+        return ReachingDefinitionsState(
+            CodeLocation(node.addr, stmt_idx=0, ins_addr=node.addr, context=self._init_context),
+            self.project.arch,
+            self.subject,
+            track_tmps=self._track_tmps,
+            track_consts=self._track_consts,
+            analysis=self,
+            canonical_size=self._canonical_size,
+            initializer=self._state_initializer,
+            element_limit=self._element_limit,
+            merge_into_tops=self._merge_into_tops,
+        )
 
     # pylint: disable=no-self-use,arguments-differ
     def _merge_states(self, _node, *states: ReachingDefinitionsState):
@@ -498,8 +491,7 @@ class ReachingDefinitionsAnalysis(
         :return:
         """
 
-        reached_fixedpoint = new_state.compare(old_state)
-        return reached_fixedpoint
+        return new_state.compare(old_state)
 
     def _run_on_node(self, node, state: ReachingDefinitionsState):
         """
@@ -576,8 +568,7 @@ class ReachingDefinitionsAnalysis(
 
         if self._node_iterations[block_key] < self._max_iterations:
             return None, state
-        else:
-            return False, state
+        return False, state
 
     def _intra_analysis(self):
         pass