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

angr/knowledge_plugins/key_definitions/uses.py

@@ -1,4 +1,5 @@
 # pylint:disable=unsubscriptable-object
+from __future__ import annotations
 from typing import Any, TYPE_CHECKING
 
 from ...utils.cowdict import DefaultChainMapCOW
@@ -20,18 +21,18 @@ class Uses:
         uses_by_definition: DefaultChainMapCOW | None = None,
         uses_by_location: DefaultChainMapCOW | None = None,
     ):
-        self._uses_by_definition: DefaultChainMapCOW["Definition", set[tuple[CodeLocation, Any | None]]] = (
+        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", Any | None]]] = (
+        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: Any | None = None):
+    def add_use(self, definition: Definition, codeloc: CodeLocation, expr: Any | None = None):
         """
         Add a use for a given definition.
 
@@ -44,7 +45,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 +53,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, Any | None]]:
+    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 +61,7 @@ class Uses:
         """
         return self._uses_by_definition.get(definition, set())
 
-    def remove_use(self, definition: "Definition", codeloc: "CodeLocation", expr: Any | None = None) -> None:
+    def remove_use(self, definition: Definition, codeloc: CodeLocation, expr: Any | None = None) -> None:
         """
         Remove one use of a given definition.
 
@@ -69,15 +70,14 @@ class Uses:
         :param expr:        The expression that uses the definition at the given location.
         :return:            None
         """
-        if definition in self._uses_by_definition:
-            if codeloc in self._uses_by_definition[definition]:
-                self._uses_by_definition = self._uses_by_definition.clean()
-                if expr is None:
-                    for codeloc_, expr_ in list(self._uses_by_definition[definition]):
-                        if codeloc_ == codeloc:
-                            self._uses_by_definition[definition].remove((codeloc_, expr_))
-                else:
-                    self._uses_by_definition[definition].remove((codeloc, expr))
+        if definition in self._uses_by_definition and codeloc in self._uses_by_definition[definition]:
+            self._uses_by_definition = self._uses_by_definition.clean()
+            if expr is None:
+                for codeloc_, expr_ in list(self._uses_by_definition[definition]):
+                    if codeloc_ == codeloc:
+                        self._uses_by_definition[definition].remove((codeloc_, expr_))
+            else:
+                self._uses_by_definition[definition].remove((codeloc, expr))
 
         if codeloc in self._uses_by_location:
             self._uses_by_location = self._uses_by_location.clean()
@@ -85,7 +85,7 @@ class Uses:
                 if item[0] == definition:
                     self._uses_by_location[codeloc].remove(item)
 
-    def remove_uses(self, definition: "Definition"):
+    def remove_uses(self, definition: Definition):
         """
         Remove all uses of a given definition.
 
@@ -105,7 +105,7 @@ class Uses:
 
     def get_uses_by_location(
         self, codeloc: CodeLocation, exprs: bool = False
-    ) -> set["Definition"] | set[tuple["Definition", Any | None]]:
+    ) -> 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
-    ) -> set["Definition"] | set[tuple["Definition", Any | None]]:
+    ) -> set[Definition] | set[tuple[Definition, Any | None]]:
         """
         Retrieve all definitions that are used at a given location specified by the instruction address.
 
@@ -135,20 +135,18 @@ class Uses:
             return all_uses
         return {item[0] for item in all_uses}
 
-    def copy(self) -> "Uses":
+    def copy(self) -> Uses:
         """
         Copy the instance.
 
         :return:    Return a new <Uses> instance containing the same data.
         """
-        u = Uses(
+        return Uses(
             uses_by_definition=self._uses_by_definition.copy(),
             uses_by_location=self._uses_by_location.copy(),
         )
 
-        return u
-
-    def merge(self, other: "Uses") -> bool:
+    def merge(self, other: Uses) -> bool:
         """
         Merge an instance of <Uses> into the current instance.
 

angr/knowledge_plugins/labels.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from archinfo.arch_arm import is_arm_arch
 import cle
 
@@ -83,8 +84,8 @@ class Labels(KnowledgeBasePlugin):
 
     def copy(self):
         o = Labels(self._kb)
-        o._labels = {k: v for k, v in self._labels.items()}
-        o._reverse_labels = {k: v for k, v in self._reverse_labels.items()}
+        o._labels = dict(self._labels.items())
+        o._reverse_labels = dict(self._reverse_labels.items())
 
     def get_unique_label(self, label):
         """

angr/knowledge_plugins/patches.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from cle.address_translator import AddressTranslator
 from sortedcontainers import SortedDict
 
@@ -93,7 +94,7 @@ class PatchManager(KnowledgeBasePlugin):
 
     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)
+            patches = sorted(self._patches.values(), key=lambda x: x.addr)
 
         if binary_bytes is None:
             with open(self._kb._project.loader.main_object.binary, "rb") as f:

angr/knowledge_plugins/plugin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -7,7 +8,7 @@ default_plugins = {}
 
 
 class KnowledgeBasePlugin:
-    def __init__(self, kb: "KnowledgeBase"):
+    def __init__(self, kb: KnowledgeBase):
         # This call is needed, because some Plugins like TypesStore inherit from KnowledgeBasePlugin and something else
         # So we still need to call the constructor of the other class.
         super().__init__()

angr/knowledge_plugins/propagations/__init__.py

@@ -1,2 +1,3 @@
+from __future__ import annotations
 from .propagation_model import PropagationModel
 from .propagation_manager import PropagationManager

angr/knowledge_plugins/propagations/prop_value.py

@@ -1,4 +1,5 @@
-from typing import Any, Optional, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 from collections.abc import Iterable, Generator
 
 import claripy
@@ -18,7 +19,7 @@ class Detail:
 
     __slots__ = ("size", "expr", "def_at")
 
-    def __init__(self, size: int, expr: ailment.Expression | None, def_at: Optional["CodeLocation"]):
+    def __init__(self, size: int, expr: ailment.Expression | None, def_at: CodeLocation | None):
         self.size = size
         self.expr = expr
         self.def_at = def_at
@@ -54,39 +55,37 @@ class PropValue:
         Get the expression that starts at offset 0 and covers the entire PropValue. Returns None if there are no
         expressions or multiple expressions.
         """
-        if self.offset_and_details and len(self.offset_and_details) == 1:
-            if 0 in self.offset_and_details:
-                detail = self.offset_and_details[0]
-                if detail.size == self.value.size() // 8:
-                    return detail.expr
+        if self.offset_and_details and len(self.offset_and_details) == 1 and 0 in self.offset_and_details:
+            detail = self.offset_and_details[0]
+            if detail.size == self.value.size() // 8:
+                return detail.expr
         return None
 
     @property
-    def one_defat(self) -> Optional["CodeLocation"]:
+    def one_defat(self) -> CodeLocation | None:
         """
         Get the definition location of the expression that starts at offset 0 and covers the entire PropValue. Returns
         None if there are no expressions or multiple expressions.
         """
-        if self.offset_and_details and len(self.offset_and_details) == 1:
-            if 0 in self.offset_and_details:
-                detail = self.offset_and_details[0]
-                if detail.size == self.value.size() // 8:
-                    return detail.def_at
+        if self.offset_and_details and len(self.offset_and_details) == 1 and 0 in self.offset_and_details:
+            detail = self.offset_and_details[0]
+            if detail.size == self.value.size() // 8:
+                return detail.def_at
         return None
 
     def to_label(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
-    def with_details(self, size: int, expr: ailment.Expression, def_at: "CodeLocation") -> "PropValue":
+    def with_details(self, size: int, expr: ailment.Expression, def_at: CodeLocation) -> PropValue:
         return PropValue(self.value, offset_and_details={0: Detail(size, expr, def_at)})
 
-    def all_exprs(self) -> Generator[ailment.Expression, None, None]:
+    def all_exprs(self) -> Generator[ailment.Expression]:
         if not self.offset_and_details:
             return
         for detail in self.offset_and_details.values():
             yield detail.expr
 
-    def non_zero_exprs(self) -> Generator[ailment.Expression, None, None]:
+    def non_zero_exprs(self) -> Generator[ailment.Expression]:
         if not self.offset_and_details:
             return
         for detail in self.offset_and_details.values():
@@ -110,10 +109,10 @@ class PropValue:
             value = claripy.fpToIEEEBV(value)
         return value[chop_start:chop_end]
 
-    def value_and_labels(self) -> Generator[tuple[int, claripy.ast.Bits, int, dict | None], None, None]:
+    def value_and_labels(self) -> Generator[tuple[int, claripy.ast.Bits, int, dict | None]]:
         if not self.offset_and_details:
             return
-        keys = list(sorted(self.offset_and_details.keys()))
+        keys = sorted(self.offset_and_details.keys())
         if keys[0] != 0:
             # missing details at 0
             yield 0, self.chop_value(self.value, 0, keys[0]), keys[0], None
@@ -142,7 +141,7 @@ class PropValue:
     @staticmethod
     def from_value_and_labels(
         value: claripy.ast.Bits, labels: Iterable[tuple[int, int, int, dict[str, Any]]]
-    ) -> "PropValue":
+    ) -> PropValue:
         if not labels:
             return PropValue(value)
         offset_and_details = {}
@@ -159,7 +158,7 @@ class PropValue:
         return PropValue(value, offset_and_details=offset_and_details)
 
     @staticmethod
-    def from_value_and_details(value: claripy.ast.Bits, size: int, expr: ailment.Expression, def_at: "CodeLocation"):
+    def from_value_and_details(value: claripy.ast.Bits, size: int, expr: ailment.Expression, def_at: CodeLocation):
         d = Detail(size, expr, def_at)
         return PropValue(value, offset_and_details={0: d})
 
@@ -176,11 +175,10 @@ class PropValue:
 
         if start == 0:
             return ailment.Expr.Convert(None, expr.bits, bits, False, expr, **expr.tags)
-        else:
-            a = ailment.Expr.BinaryOp(
-                None, "Shr", (expr, ailment.Expr.Const(None, None, bits, expr.bits)), False, **expr.tags
-            )
-            return ailment.Expr.Convert(None, a.bits, bits, False, a, **expr.tags)
+        a = ailment.Expr.BinaryOp(
+            None, "Shr", (expr, ailment.Expr.Const(None, None, bits, expr.bits)), False, **expr.tags
+        )
+        return ailment.Expr.Convert(None, a.bits, bits, False, a, **expr.tags)
 
     @staticmethod
     def extend_ail_expression(bits: int, expr: ailment.Expr.Expression | None) -> ailment.Expr.Expression | None:
@@ -188,6 +186,6 @@ class PropValue:
             return None
         if isinstance(expr, ailment.Expr.Const):
             return ailment.Expr.Const(expr.idx, expr.variable, expr.value, bits + expr.bits, **expr.tags)
-        elif isinstance(expr, ailment.Expr.Convert):
+        if isinstance(expr, ailment.Expr.Convert):
             return ailment.Expr.Convert(None, expr.from_bits, bits + expr.to_bits, False, expr.operand, **expr.tags)
         return ailment.Expr.Convert(None, expr.bits, bits + expr.bits, False, expr, **expr.tags)

angr/knowledge_plugins/propagations/propagation_manager.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from angr.knowledge_plugins.plugin import KnowledgeBasePlugin
 from .propagation_model import PropagationModel
 
@@ -42,8 +43,7 @@ class PropagationManager(KnowledgeBasePlugin):
         """
         if prop_key in self._propagations:
             return self._propagations[prop_key]
-        else:
-            return default
+        return default
 
     def copy(self):
         o = PropagationManager(self._kb)

angr/knowledge_plugins/propagations/propagation_model.py

@@ -1,4 +1,5 @@
-from typing import DefaultDict, Any
+from __future__ import annotations
+from typing import Any
 from collections import defaultdict
 
 import claripy
@@ -30,10 +31,10 @@ class PropagationModel(Serializable):
     def __init__(
         self,
         prop_key: tuple,
-        node_iterations: DefaultDict[Any, int] | None = None,
+        node_iterations: defaultdict[Any, int] | None = None,
         states: dict | None = None,
         block_initial_reg_values: dict | None = None,
-        replacements: DefaultDict[Any, dict] | None = None,
+        replacements: defaultdict[Any, dict] | None = None,
         equivalence: set | None = None,
         function: Function | None = None,
         input_states: dict | None = None,
@@ -59,7 +60,7 @@ class PropagationModel(Serializable):
 
     def block_beginning_state(self, block_addr) -> PropagatorState:
         if self._function is None:
-            raise NotImplementedError()
+            raise NotImplementedError
 
         node = self._function.get_node(block_addr)
         preds = [self.states[pnode.addr] for pnode in self._function.graph.predecessors(node)]

angr/knowledge_plugins/propagations/states.py

@@ -1,5 +1,6 @@
 # pylint:disable=too-many-boolean-expressions
-from typing import Optional, Union, DefaultDict, Any, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 from collections import defaultdict
 import weakref
 
@@ -49,7 +50,7 @@ class PropagatorState:
     Describes the base state used in Propagator.
 
     :ivar arch:             Architecture of the binary.
-    :ivar gp:               alue of the global pointer for MIPS binaries.
+    :ivar gp:               value of the global pointer for MIPS binaries.
     :ivar _replacements:    Stores expressions to replace, keyed by CodeLocation instances
     :ivar _equivalence:      Stores equivalence constraints that Propagator discovers during the analysis.
     :ivar _only_consts:     Only track constants.
@@ -81,13 +82,13 @@ class PropagatorState:
 
     def __init__(
         self,
-        arch: "Arch",
-        project: Optional["Project"] = None,
+        arch: Arch,
+        project: Project | None = None,
         rda=None,
-        replacements: DefaultDict[CodeLocation, dict] | None = None,
+        replacements: defaultdict[CodeLocation, dict] | None = None,
         only_consts: bool = False,
-        expr_used_locs: DefaultDict[Any, set[CodeLocation]] | None = None,
-        equivalence: set["Equivalence"] | None = None,
+        expr_used_locs: defaultdict[Any, set[CodeLocation]] | None = None,
+        equivalence: set[Equivalence] | None = None,
         store_tops: bool = True,
         gp: int | None = None,
         max_prop_expr_occurrence: int = 1,
@@ -129,7 +130,7 @@ class PropagatorState:
         max_prop_expr_occurrence=None,
         initial_codeloc=None,
     ):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _get_weakref(self):
         return weakref.proxy(self)
@@ -142,14 +143,12 @@ class PropagatorState:
             return True
         if isinstance(v, claripy.ast.FP) and v.op == "FPV":
             return True
-        if isinstance(v, claripy.ast.Bool) and v.op == "BoolV":
-            return True
-        return False
+        return bool(isinstance(v, claripy.ast.Bool) and v.op == "BoolV")
 
     @staticmethod
     def _mo_cmp(
-        mo_self: Union["SimMemoryObject", "SimLabeledMemoryObject"],
-        mo_other: Union["SimMemoryObject", "SimLabeledMemoryObject"],
+        mo_self: SimMemoryObject | SimLabeledMemoryObject,
+        mo_other: SimMemoryObject | SimLabeledMemoryObject,
         addr: int,
         size: int,
     ):  # pylint:disable=unused-argument
@@ -229,21 +228,23 @@ class PropagatorState:
                                 replacements_0[loc][var] = t
                                 merge_occurred = True
                         elif (
-                            isinstance(replacements_0[loc][var], claripy.ast.Base) or isinstance(repl, claripy.ast.Base)
-                        ) and replacements_0[loc][var] is not repl:
-                            replacements_0[loc][var] = repl
-                            merge_occurred = True
-                        elif (
-                            not isinstance(replacements_0[loc][var], claripy.ast.Base)
-                            and not isinstance(repl, claripy.ast.Base)
-                            and replacements_0[loc][var] != repl
+                            (
+                                isinstance(replacements_0[loc][var], claripy.ast.Base)
+                                or isinstance(repl, claripy.ast.Base)
+                            )
+                            and replacements_0[loc][var] is not repl
+                            or (
+                                not isinstance(replacements_0[loc][var], claripy.ast.Base)
+                                and not isinstance(repl, claripy.ast.Base)
+                                and replacements_0[loc][var] != repl
+                            )
                         ):
                             replacements_0[loc][var] = repl
                             merge_occurred = True
         return merge_occurred
 
-    def copy(self) -> "PropagatorState":
-        raise NotImplementedError()
+    def copy(self) -> PropagatorState:
+        raise NotImplementedError
 
     def merge(self, *others):
         state = self.copy()
@@ -295,9 +296,7 @@ class PropagatorState:
             return False
         if codeloc not in self._replacements:
             return False
-        if all(self.is_top(replaced_by) for replaced_by in self._replacements[codeloc].values()):
-            return False
-        return True
+        return not all(self.is_top(replaced_by) for replaced_by in self._replacements[codeloc].values())
 
 
 # VEX state
@@ -351,7 +350,7 @@ class RegisterComparisonAnnotation(claripy.Annotation):
 
     def __eq__(self, other):
         return (
-            type(other) is RegisterAnnotation
+            type(other) is RegisterComparisonAnnotation
             and self.offset == other.offset
             and self.size == other.size
             and self.cmp_op == other.cmp_op
@@ -476,8 +475,8 @@ class PropagatorVEXState(PropagatorState):
             )
         return state
 
-    def copy(self) -> "PropagatorVEXState":
-        cp = PropagatorVEXState(
+    def copy(self) -> PropagatorVEXState:
+        return PropagatorVEXState(
             self.arch,
             project=self.project,
             rda=self.rda,
@@ -495,9 +494,7 @@ class PropagatorVEXState(PropagatorState):
             artificial_reg_offsets=self._artificial_reg_offsets,
         )
 
-        return cp
-
-    def merge(self, *others: "PropagatorVEXState") -> tuple["PropagatorVEXState", bool]:
+    def merge(self, *others: PropagatorVEXState) -> tuple[PropagatorVEXState, bool]:
         state = self.copy()
         merge_occurred = state._registers.merge([o._registers for o in others], None)
         merge_occurred |= state._stack_variables.merge([o._stack_variables for o in others], None)
@@ -636,7 +633,7 @@ class PropagatorAILState(PropagatorState):
         self._tmps = {}
         self.temp_expressions = {}
         self.register_expressions = {}
-        self.block_initial_reg_values: DefaultDict[
+        self.block_initial_reg_values: defaultdict[
             tuple[int, int], list[tuple[ailment.Expr.Register, ailment.Expr.Const]]
         ] = (defaultdict(list) if block_initial_reg_values is None else block_initial_reg_values)
         self._sp_adjusted: bool = sp_adjusted
@@ -732,24 +729,28 @@ class PropagatorAILState(PropagatorState):
                 PropValue(claripy.BVV(0, 8), offset_and_details={0: Detail(1, reg_value, initial_codeloc)}),
             )
 
-        if project is not None and project.simos is not None and project.simos.function_initial_registers:
-            if func_addr is not None:
-                for reg_name, reg_value in project.simos.function_initial_registers.items():
-                    reg_size = project.arch.registers[reg_name][1]
-                    reg_expr = ailment.Expr.Register(None, None, project.arch.registers[reg_name][0], reg_size)
-                    reg_value_expr = ailment.Expr.Const(None, None, reg_value, reg_size * 8)
-                    state.store_register(
-                        reg_expr,
-                        PropValue(
-                            claripy.BVV(reg_value, project.arch.bits),
-                            offset_and_details={0: Detail(reg_size, reg_value_expr, initial_codeloc)},
-                        ),
-                    )
+        if (
+            project is not None
+            and project.simos is not None
+            and project.simos.function_initial_registers
+            and func_addr is not None
+        ):
+            for reg_name, reg_value in project.simos.function_initial_registers.items():
+                reg_size = project.arch.registers[reg_name][1]
+                reg_expr = ailment.Expr.Register(None, None, project.arch.registers[reg_name][0], reg_size)
+                reg_value_expr = ailment.Expr.Const(None, None, reg_value, reg_size * 8)
+                state.store_register(
+                    reg_expr,
+                    PropValue(
+                        claripy.BVV(reg_value, project.arch.bits),
+                        offset_and_details={0: Detail(reg_size, reg_value_expr, initial_codeloc)},
+                    ),
+                )
 
         return state
 
-    def copy(self) -> "PropagatorAILState":
-        rd = PropagatorAILState(
+    def copy(self) -> PropagatorAILState:
+        return PropagatorAILState(
             self.arch,
             project=self.project,
             rda=self.rda,
@@ -768,8 +769,6 @@ class PropagatorAILState(PropagatorState):
             artificial_reg_offsets=self._artificial_reg_offsets,
         )
 
-        return rd
-
     @staticmethod
     def is_const_or_register(value: ailment.Expr.Expression | claripy.ast.Bits | None) -> bool:
         if value is None:
@@ -783,17 +782,18 @@ class PropagatorAILState(PropagatorState):
         if isinstance(value, ailment.Expr.StackBaseOffset):
             return True
         # more hacks: also store the eq comparisons
-        if isinstance(value, ailment.Expr.BinaryOp) and value.op == "CmpEQ":
-            if all(isinstance(arg, (ailment.Expr.Const, ailment.Expr.Tmp)) for arg in value.operands):
-                return True
-        # more hacks: also store the conversions
-        if isinstance(value, ailment.Expr.Convert) and PropagatorAILState.is_const_or_register(value.operand):
+        if (
+            isinstance(value, ailment.Expr.BinaryOp)
+            and value.op == "CmpEQ"
+            and all(isinstance(arg, (ailment.Expr.Const, ailment.Expr.Tmp)) for arg in value.operands)
+        ):
             return True
-        return False
+        # more hacks: also store the conversions
+        return bool(isinstance(value, ailment.Expr.Convert) and PropagatorAILState.is_const_or_register(value.operand))
 
-    def merge(self, *others) -> tuple["PropagatorAILState", bool]:
+    def merge(self, *others) -> tuple[PropagatorAILState, bool]:
         state, merge_occurred = super().merge(*others)
-        state: "PropagatorAILState"
+        state: PropagatorAILState
 
         merge_occurred |= state._registers.merge([o._registers for o in others], None)
         merge_occurred |= state._stack_variables.merge([o._stack_variables for o in others], None)
@@ -838,8 +838,7 @@ class PropagatorAILState(PropagatorState):
             # value does not exist
             return None
 
-        prop_value = PropValue.from_value_and_labels(value, labels)
-        return prop_value
+        return PropValue.from_value_and_labels(value, labels)
 
     def load_stack_variable(self, sp_offset: int, size, endness=None) -> PropValue | None:
         # normalize sp_offset to handle negative offsets
@@ -866,17 +865,14 @@ class PropagatorAILState(PropagatorState):
             else:
                 return None
 
-        prop_value = PropValue.from_value_and_labels(value, labels)
-        return prop_value
+        return PropValue.from_value_and_labels(value, labels)
 
     def should_replace_reg(self, old_reg_offset: int, bp_as_gpr: bool, new_value) -> bool:
         if old_reg_offset == self.arch.sp_offset or (not bp_as_gpr and old_reg_offset == self.arch.bp_offset):
             return True
         if old_reg_offset in self._artificial_reg_offsets:
             return True
-        if isinstance(new_value, ailment.Expr.StackBaseOffset):
-            return True
-        return False
+        return bool(isinstance(new_value, ailment.Expr.StackBaseOffset))
 
     def add_replacement(
         self,
@@ -896,11 +892,10 @@ class PropagatorAILState(PropagatorState):
         # do not replace anything with a call expression
         if isinstance(new, ailment.statement.Call):
             return False
-        else:
-            callexpr_finder = CallExprFinder()
-            callexpr_finder.walk_expression(new)
-            if callexpr_finder.has_call:
-                return False
+        callexpr_finder = CallExprFinder()
+        callexpr_finder.walk_expression(new)
+        if callexpr_finder.has_call:
+            return False
 
         if self.is_top(new):
             self._replacements[codeloc][old] = self.top(1)  # placeholder
@@ -1002,10 +997,9 @@ class PropagatorAILState(PropagatorState):
                 for key, replace_with in list(self._replacements[codeloc_].items()):
                     if isinstance(replace_with, dict):
                         replace_with = replace_with["expr"]
-                    if not self.is_top(replace_with) and replace_with == replaced_by:
-                        if to_replace.likes(key):
-                            self._replacements[codeloc_][key] = self.top(1)
-                            updated_codelocs.add(codeloc_)
+                    if not self.is_top(replace_with) and replace_with == replaced_by and to_replace.likes(key):
+                        self._replacements[codeloc_][key] = self.top(1)
+                        updated_codelocs.add(codeloc_)
 
         return updated_codelocs
 
@@ -1017,7 +1011,7 @@ class PropagatorAILState(PropagatorState):
     def is_simple_expression(expr: ailment.Expr.Expression) -> bool:
         if PropagatorAILState.is_shallow_expression(expr):
             return True
-        if (
+        return bool(
             isinstance(expr, ailment.Expr.BinaryOp)
             and expr.op in {"Add", "Sub"}
             and (
@@ -1026,9 +1020,7 @@ class PropagatorAILState(PropagatorState):
                 or isinstance(expr.operands[1], ailment.Expr.Register)
                 and PropagatorAILState.is_global_variable_load(expr.operands[0])
             )
-        ):
-            return True
-        return False
+        )
 
     @staticmethod
     def is_shallow_expression(expr: ailment.Expr.Expression) -> bool:
@@ -1038,9 +1030,7 @@ class PropagatorAILState(PropagatorState):
     def is_global_variable_load(expr: ailment.Expr.Expression) -> bool:
         if isinstance(expr, ailment.Expr.Load) and isinstance(expr.addr, ailment.Expr.Const):
             return True
-        if isinstance(expr, ailment.Expr.Convert) and PropagatorAILState.is_global_variable_load(expr.operand):
-            return True
-        return False
+        return bool(isinstance(expr, ailment.Expr.Convert) and PropagatorAILState.is_global_variable_load(expr.operand))
 
     @staticmethod
     def is_expression_too_deep(expr: ailment.Expr.Expression) -> bool:

angr/knowledge_plugins/structured_code/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .manager import StructuredCodeManager