slither.core.declarations.function

   1"""
   2Function module
   3"""
   4
   5import logging
   6from abc import abstractmethod, ABCMeta
   7from collections import namedtuple
   8from enum import Enum
   9from itertools import groupby
  10from typing import Any, TYPE_CHECKING, Optional, Union
  11from collections.abc import Callable
  12
  13from slither.core.cfg.scope import Scope
  14from slither.core.declarations.solidity_variables import (
  15    SolidityFunction,
  16    SolidityVariable,
  17    SolidityVariableComposed,
  18)
  19from slither.core.expressions import (
  20    Identifier,
  21    IndexAccess,
  22    MemberAccess,
  23    UnaryOperation,
  24)
  25from slither.core.solidity_types.type import Type
  26from slither.core.source_mapping.source_mapping import SourceMapping
  27from slither.core.variables.local_variable import LocalVariable
  28from slither.core.variables.state_variable import StateVariable
  29from slither.utils.type import convert_type_for_solidity_signature_to_string
  30from slither.utils.utils import unroll
  31
  32
  33if TYPE_CHECKING:
  34    from slither.core.declarations import Contract, FunctionContract
  35    from slither.core.cfg.node import Node, NodeType
  36    from slither.core.variables.variable import Variable
  37    from slither.slithir.variables.variable import SlithIRVariable
  38    from slither.slithir.variables import LocalIRVariable
  39    from slither.core.expressions.expression import Expression
  40    from slither.slithir.operations import (
  41        HighLevelCall,
  42        InternalCall,
  43        LibraryCall,
  44        LowLevelCall,
  45        SolidityCall,
  46        Operation,
  47    )
  48    from slither.core.compilation_unit import SlitherCompilationUnit
  49    from slither.core.scope.scope import FileScope
  50
  51LOGGER = logging.getLogger("Function")
  52ReacheableNode = namedtuple("ReacheableNode", ["node", "ir"])
  53
  54
  55class ModifierStatements:
  56    def __init__(
  57        self,
  58        modifier: Union["Contract", "Function"],
  59        entry_point: "Node",
  60        nodes: list["Node"],
  61    ) -> None:
  62        self._modifier = modifier
  63        self._entry_point = entry_point
  64        self._nodes = nodes
  65
  66    @property
  67    def modifier(self) -> Union["Contract", "Function"]:
  68        return self._modifier
  69
  70    @property
  71    def entry_point(self) -> "Node":
  72        return self._entry_point
  73
  74    @entry_point.setter
  75    def entry_point(self, entry_point: "Node"):
  76        self._entry_point = entry_point
  77
  78    @property
  79    def nodes(self) -> list["Node"]:
  80        return self._nodes
  81
  82    @nodes.setter
  83    def nodes(self, nodes: list["Node"]):
  84        self._nodes = nodes
  85
  86
  87class FunctionType(Enum):
  88    NORMAL = 0
  89    CONSTRUCTOR = 1
  90    FALLBACK = 2
  91    RECEIVE = 3
  92    CONSTRUCTOR_VARIABLES = 10  # Fake function to hold variable declaration statements
  93    CONSTRUCTOR_CONSTANT_VARIABLES = 11  # Fake function to hold variable declaration statements
  94
  95
  96def _filter_state_variables_written(expressions: list["Expression"]):
  97    ret = []
  98
  99    for expression in expressions:
 100        if isinstance(expression, (Identifier, UnaryOperation, MemberAccess)):
 101            ret.append(expression.expression)
 102        elif isinstance(expression, IndexAccess):
 103            ret.append(expression.expression_left)
 104    return ret
 105
 106
 107class FunctionLanguage(Enum):
 108    Solidity = 0
 109    Yul = 1
 110    Vyper = 2
 111
 112
 113class Function(SourceMapping, metaclass=ABCMeta):
 114    """
 115    Function class
 116    """
 117
 118    def __init__(self, compilation_unit: "SlitherCompilationUnit") -> None:
 119        super().__init__()
 120        self._internal_scope: list[str] = []
 121        self._name: str | None = None
 122        self._view: bool = False
 123        self._pure: bool = False
 124        self._payable: bool = False
 125        self._visibility: str | None = None
 126        self._virtual: bool = False
 127        self._overrides: list[FunctionContract] = []
 128        self._overridden_by: list[FunctionContract] = []
 129
 130        self._is_implemented: bool | None = None
 131        self._is_empty: bool | None = None
 132        self._entry_point: Node | None = None
 133        self._nodes: list[Node] = []
 134        self._variables: dict[str, LocalVariable] = {}
 135        # slithir Temporary and references variables (but not SSA)
 136        self._slithir_variables: set[SlithIRVariable] = set()
 137        self._parameters: list[LocalVariable] = []
 138        self._parameters_ssa: list[LocalIRVariable] = []
 139        self._parameters_src: SourceMapping = SourceMapping()
 140        # This is used for vyper calls with default arguments
 141        self._default_args_as_expressions: list[Expression] = []
 142        self._returns: list[LocalVariable] = []
 143        self._returns_ssa: list[LocalIRVariable] = []
 144        self._returns_src: SourceMapping = SourceMapping()
 145        self._return_values: list[SlithIRVariable] | None = None
 146        self._return_values_ssa: list[SlithIRVariable] | None = None
 147        self._vars_read: list[Variable] = []
 148        self._vars_written: list[Variable] = []
 149        self._state_vars_read: list[StateVariable] = []
 150        self._vars_read_or_written: list[Variable] = []
 151        self._solidity_vars_read: list[SolidityVariable] = []
 152        self._state_vars_written: list[StateVariable] = []
 153        self._internal_calls: list[InternalCall] = []
 154        self._solidity_calls: list[SolidityCall] = []
 155        self._low_level_calls: list[LowLevelCall] = []
 156        self._high_level_calls: list[tuple[Contract, HighLevelCall]] = []
 157        self._library_calls: list[LibraryCall] = []
 158        self._external_calls_as_expressions: list[Expression] = []
 159        self._expression_vars_read: list[Expression] = []
 160        self._expression_vars_written: list[Expression] = []
 161        self._expression_calls: list[Expression] = []
 162        # self._expression_modifiers: List["Expression"] = []
 163        self._modifiers: list[ModifierStatements] = []
 164        self._explicit_base_constructor_calls: list[ModifierStatements] = []
 165        self._contains_assembly: bool = False
 166
 167        self._expressions: list[Expression] | None = None
 168        self._slithir_operations: list[Operation] | None = None
 169        self._slithir_ssa_operations: list[Operation] | None = None
 170
 171        self._all_expressions: list[Expression] | None = None
 172        self._all_slithir_operations: list[Operation] | None = None
 173        self._all_internals_calls: list[InternalCall] | None = None
 174        self._all_high_level_calls: list[tuple[Contract, HighLevelCall]] | None = None
 175        self._all_library_calls: list[LibraryCall] | None = None
 176        self._all_low_level_calls: list[LowLevelCall] | None = None
 177        self._all_solidity_calls: list[SolidityCall] | None = None
 178        self._all_variables_read: list[Variable] | None = None
 179        self._all_variables_written: list[Variable] | None = None
 180        self._all_state_variables_read: list[StateVariable] | None = None
 181        self._all_solidity_variables_read: list[SolidityVariable] | None = None
 182        self._all_state_variables_written: list[StateVariable] | None = None
 183        self._all_slithir_variables: list[SlithIRVariable] | None = None
 184        self._all_nodes: list[Node] | None = None
 185        self._all_conditional_state_variables_read: list[StateVariable] | None = None
 186        self._all_conditional_state_variables_read_with_loop: list[StateVariable] | None = None
 187        self._all_conditional_solidity_variables_read: list[SolidityVariable] | None = None
 188        self._all_conditional_solidity_variables_read_with_loop: list[SolidityVariable] | None = (
 189            None
 190        )
 191        self._all_solidity_variables_used_as_args: list[SolidityVariable] | None = None
 192
 193        self._is_shadowed: bool = False
 194        self._shadows: bool = False
 195
 196        # set(ReacheableNode)
 197        self._reachable_from_nodes: set[ReacheableNode] = set()
 198        self._reachable_from_functions: set[Function] = set()
 199        self._all_reachable_from_functions: set[Function] | None = None
 200
 201        # Constructor, fallback, State variable constructor
 202        self._function_type: FunctionType | None = None
 203        self._is_constructor: bool | None = None
 204
 205        # Computed on the fly, can be True of False
 206        self._can_reenter: bool | None = None
 207        self._can_send_eth: bool | None = None
 208
 209        self._nodes_ordered_dominators: list[Node] | None = None
 210
 211        self._counter_nodes = 0
 212
 213        # Memoize parameters:
 214        # TODO: identify all the memoize parameters and add a way to undo the memoization
 215        self._full_name: str | None = None
 216        self._signature: tuple[str, list[str], list[str]] | None = None
 217        self._solidity_signature: str | None = None
 218        self._signature_str: str | None = None
 219        self._canonical_name: str | None = None
 220        self._is_protected: bool | None = None
 221
 222        self.compilation_unit: SlitherCompilationUnit = compilation_unit
 223
 224        self.function_language: FunctionLanguage = (
 225            FunctionLanguage.Solidity if compilation_unit.is_solidity else FunctionLanguage.Vyper
 226        )
 227
 228        self._id: str | None = None
 229
 230        # To be improved with a parsing of the documentation
 231        self.has_documentation: bool = False
 232
 233    ###################################################################################
 234    ###################################################################################
 235    # region General properties
 236    ###################################################################################
 237    ###################################################################################
 238
 239    @property
 240    def name(self) -> str:
 241        """
 242        str: function name
 243        """
 244        if self._name == "" and self._function_type == FunctionType.CONSTRUCTOR:
 245            return "constructor"
 246        if self._name == "" and self._function_type == FunctionType.FALLBACK:
 247            return "fallback"
 248        if self._function_type == FunctionType.RECEIVE:
 249            return "receive"
 250        if self._function_type == FunctionType.CONSTRUCTOR_VARIABLES:
 251            return "slitherConstructorVariables"
 252        if self._function_type == FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES:
 253            return "slitherConstructorConstantVariables"
 254        return self._name
 255
 256    @name.setter
 257    def name(self, new_name: str):
 258        self._name = new_name
 259
 260    @property
 261    def internal_scope(self) -> list[str]:
 262        """
 263        Return a list of name representing the scope of the function
 264        This is used to model nested functions declared in YUL
 265
 266        :return:
 267        """
 268        return self._internal_scope
 269
 270    @internal_scope.setter
 271    def internal_scope(self, new_scope: list[str]):
 272        self._internal_scope = new_scope
 273
 274    @property
 275    def full_name(self) -> str:
 276        """
 277        str: func_name(type1,type2)
 278        Return the function signature without the return values
 279        The difference between this function and solidity_function is that full_name does not translate the underlying
 280        type (ex: structure, contract to address, ...)
 281        """
 282        if self._full_name is None:
 283            name, parameters, _ = self.signature
 284            full_name = ".".join(self._internal_scope + [name]) + "(" + ",".join(parameters) + ")"
 285            self._full_name = full_name
 286        return self._full_name
 287
 288    @property
 289    @abstractmethod
 290    def canonical_name(self) -> str:
 291        """
 292        str: contract.func_name(type1,type2)
 293        Return the function signature without the return values
 294        """
 295        return ""
 296
 297    @property
 298    def contains_assembly(self) -> bool:
 299        return self._contains_assembly
 300
 301    @contains_assembly.setter
 302    def contains_assembly(self, c: bool):
 303        self._contains_assembly = c
 304
 305    def can_reenter(self, callstack: list[Union["Function", "Variable"]] | None = None) -> bool:
 306        """
 307        Check if the function can re-enter
 308        Follow internal calls.
 309        Do not consider CREATE as potential re-enter, but check if the
 310        destination's constructor can contain a call (recurs. follow nested CREATE)
 311        For Solidity > 0.5, filter access to public variables and constant/pure/view
 312        For call to this. check if the destination can re-enter
 313        Do not consider Send/Transfer as there is not enough gas
 314        :param callstack: used internally to check for recursion
 315        :return bool:
 316        """
 317        from slither.slithir.operations import Call
 318
 319        if self._can_reenter is None:
 320            self._can_reenter = False
 321            for ir in self.all_slithir_operations():
 322                if isinstance(ir, Call) and ir.can_reenter(callstack):
 323                    self._can_reenter = True
 324                    return True
 325        return self._can_reenter
 326
 327    def can_send_eth(self) -> bool:
 328        """
 329        Check if the function or any internal (not external) functions called by it can send eth
 330        :return bool:
 331        """
 332        from slither.slithir.operations import Call
 333
 334        if self._can_send_eth is None:
 335            self._can_send_eth = False
 336            for ir in self.all_slithir_operations():
 337                if isinstance(ir, Call) and ir.can_send_eth():
 338                    self._can_send_eth = True
 339                    return True
 340        return self._can_send_eth
 341
 342    @property
 343    def is_checked(self) -> bool:
 344        """
 345        Return true if the overflow are enabled by default
 346
 347
 348        :return:
 349        """
 350
 351        return self.compilation_unit.solc_version >= "0.8.0"
 352
 353    @property
 354    def id(self) -> str | None:
 355        """
 356        Return the reference ID of the function, if available.
 357
 358        :return:
 359        :rtype:
 360        """
 361        return self._id
 362
 363    @id.setter
 364    def id(self, new_id: str):
 365        self._id = new_id
 366
 367    @property
 368    @abstractmethod
 369    def file_scope(self) -> "FileScope":
 370        pass
 371
 372    # endregion
 373    ###################################################################################
 374    ###################################################################################
 375    # region Type (FunctionType)
 376    ###################################################################################
 377    ###################################################################################
 378
 379    def set_function_type(self, t: FunctionType) -> None:
 380        assert isinstance(t, FunctionType)
 381        self._function_type = t
 382
 383    @property
 384    def function_type(self) -> FunctionType | None:
 385        return self._function_type
 386
 387    @function_type.setter
 388    def function_type(self, t: FunctionType):
 389        self._function_type = t
 390
 391    @property
 392    def is_constructor(self) -> bool:
 393        """
 394        bool: True if the function is the constructor
 395        """
 396        return self._function_type == FunctionType.CONSTRUCTOR
 397
 398    @property
 399    def is_constructor_variables(self) -> bool:
 400        """
 401        bool: True if the function is the constructor of the variables
 402        Slither has inbuilt functions to hold the state variables initialization
 403        """
 404        return self._function_type in [
 405            FunctionType.CONSTRUCTOR_VARIABLES,
 406            FunctionType.CONSTRUCTOR_CONSTANT_VARIABLES,
 407        ]
 408
 409    @property
 410    def is_fallback(self) -> bool:
 411        """
 412            Determine if the function is the fallback function for the contract
 413        Returns
 414            (bool)
 415        """
 416        return self._function_type == FunctionType.FALLBACK
 417
 418    @property
 419    def is_receive(self) -> bool:
 420        """
 421            Determine if the function is the receive function for the contract
 422        Returns
 423            (bool)
 424        """
 425        return self._function_type == FunctionType.RECEIVE
 426
 427    # endregion
 428    ###################################################################################
 429    ###################################################################################
 430    # region Payable
 431    ###################################################################################
 432    ###################################################################################
 433
 434    @property
 435    def payable(self) -> bool:
 436        """
 437        bool: True if the function is payable
 438        """
 439        return self._payable
 440
 441    @payable.setter
 442    def payable(self, p: bool):
 443        self._payable = p
 444
 445    # endregion
 446    ###################################################################################
 447    ###################################################################################
 448    # region Virtual
 449    ###################################################################################
 450    ###################################################################################
 451
 452    @property
 453    def is_virtual(self) -> bool:
 454        """
 455        Note for Solidity < 0.6.0 it will always be false
 456        bool: True if the function is virtual
 457        """
 458        return self._virtual
 459
 460    @is_virtual.setter
 461    def is_virtual(self, v: bool):
 462        self._virtual = v
 463
 464    @property
 465    def is_override(self) -> bool:
 466        """
 467        Note for Solidity < 0.6.0 it will always be false
 468        bool: True if the function overrides a base function
 469        """
 470        return len(self._overrides) > 0
 471
 472    @property
 473    def overridden_by(self) -> list["FunctionContract"]:
 474        """
 475        List["FunctionContract"]: List of functions in child contracts that override this function
 476        This may include distinct instances of the same function due to inheritance
 477        """
 478        return self._overridden_by
 479
 480    @property
 481    def overrides(self) -> list["FunctionContract"]:
 482        """
 483        List["FunctionContract"]: List of functions in parent contracts that this function overrides
 484        This may include distinct instances of the same function due to inheritance
 485        """
 486        return self._overrides
 487
 488    # endregion
 489    ###################################################################################
 490    ###################################################################################
 491    # region Visibility
 492    ###################################################################################
 493    ###################################################################################
 494
 495    @property
 496    def visibility(self) -> str:
 497        """
 498        str: Function visibility
 499        """
 500        assert self._visibility is not None
 501        return self._visibility
 502
 503    @visibility.setter
 504    def visibility(self, v: str):
 505        self._visibility = v
 506
 507    def set_visibility(self, v: str) -> None:
 508        self._visibility = v
 509
 510    @property
 511    def view(self) -> bool:
 512        """
 513        bool: True if the function is declared as view
 514        """
 515        return self._view
 516
 517    @view.setter
 518    def view(self, v: bool):
 519        self._view = v
 520
 521    @property
 522    def pure(self) -> bool:
 523        """
 524        bool: True if the function is declared as pure
 525        """
 526        return self._pure
 527
 528    @pure.setter
 529    def pure(self, p: bool):
 530        self._pure = p
 531
 532    @property
 533    def is_shadowed(self) -> bool:
 534        return self._is_shadowed
 535
 536    @is_shadowed.setter
 537    def is_shadowed(self, is_shadowed):
 538        self._is_shadowed = is_shadowed
 539
 540    @property
 541    def shadows(self) -> bool:
 542        return self._shadows
 543
 544    @shadows.setter
 545    def shadows(self, _shadows: bool):
 546        self._shadows = _shadows
 547
 548    # endregion
 549    ###################################################################################
 550    ###################################################################################
 551    # region Function's body
 552    ###################################################################################
 553    ###################################################################################
 554
 555    @property
 556    def is_implemented(self) -> bool:
 557        """
 558        bool: True if the function is implemented
 559        """
 560        return self._is_implemented
 561
 562    @is_implemented.setter
 563    def is_implemented(self, is_impl: bool):
 564        self._is_implemented = is_impl
 565
 566    @property
 567    def is_empty(self) -> bool:
 568        """
 569        bool: True if the function is empty, None if the function is an interface
 570        """
 571        return self._is_empty
 572
 573    @is_empty.setter
 574    def is_empty(self, empty: bool):
 575        self._is_empty = empty
 576
 577    # endregion
 578    ###################################################################################
 579    ###################################################################################
 580    # region Nodes
 581    ###################################################################################
 582    ###################################################################################
 583
 584    @property
 585    def nodes(self) -> list["Node"]:
 586        """
 587        list(Node): List of the nodes
 588        """
 589        return list(self._nodes)
 590
 591    @nodes.setter
 592    def nodes(self, nodes: list["Node"]):
 593        self._nodes = nodes
 594
 595    @property
 596    def entry_point(self) -> Optional["Node"]:
 597        """
 598        Node: Entry point of the function
 599        """
 600        return self._entry_point
 601
 602    @entry_point.setter
 603    def entry_point(self, node: "Node"):
 604        self._entry_point = node
 605
 606    def add_node(self, node: "Node") -> None:
 607        if not self._entry_point:
 608            self._entry_point = node
 609        self._nodes.append(node)
 610
 611    @property
 612    def nodes_ordered_dominators(self) -> list["Node"]:
 613        # TODO: does not work properly; most likely due to modifier call
 614        # This will not work for modifier call that lead to multiple nodes
 615        # from slither.core.cfg.node import NodeType
 616        if self._nodes_ordered_dominators is None:
 617            self._nodes_ordered_dominators = []
 618            if self.entry_point:
 619                self._compute_nodes_ordered_dominators(self.entry_point)
 620
 621            for node in self.nodes:
 622                # if node.type == NodeType.OTHER_ENTRYPOINT:
 623                if node not in self._nodes_ordered_dominators:
 624                    self._compute_nodes_ordered_dominators(node)
 625
 626        return self._nodes_ordered_dominators
 627
 628    def _compute_nodes_ordered_dominators(self, node: "Node"):
 629        assert self._nodes_ordered_dominators is not None
 630        if node in self._nodes_ordered_dominators:
 631            return
 632        self._nodes_ordered_dominators.append(node)
 633        for dom in node.dominance_exploration_ordered:
 634            self._compute_nodes_ordered_dominators(dom)
 635
 636    # endregion
 637    ###################################################################################
 638    ###################################################################################
 639    # region Parameters
 640    ###################################################################################
 641    ###################################################################################
 642
 643    @property
 644    def parameters(self) -> list["LocalVariable"]:
 645        """
 646        list(LocalVariable): List of the parameters
 647        """
 648        return list(self._parameters)
 649
 650    def add_parameters(self, p: "LocalVariable") -> None:
 651        self._parameters.append(p)
 652
 653    @property
 654    def parameters_ssa(self) -> list["LocalIRVariable"]:
 655        """
 656        list(LocalIRVariable): List of the parameters (SSA form)
 657        """
 658        return list(self._parameters_ssa)
 659
 660    def add_parameter_ssa(self, var: "LocalIRVariable") -> None:
 661        self._parameters_ssa.append(var)
 662
 663    def parameters_src(self) -> SourceMapping:
 664        return self._parameters_src
 665
 666    # endregion
 667    ###################################################################################
 668    ###################################################################################
 669    # region Return values
 670    ###################################################################################
 671    ###################################################################################
 672
 673    @property
 674    def return_type(self) -> list[Type] | None:
 675        """
 676        Return the list of return type
 677        If no return, return None
 678        """
 679        returns = self.returns
 680        if returns:
 681            return [r.type for r in returns]
 682        return None
 683
 684    def returns_src(self) -> SourceMapping:
 685        return self._returns_src
 686
 687    @property
 688    def type(self) -> list[Type] | None:
 689        """
 690        Return the list of return type
 691        If no return, return None
 692        Alias of return_type
 693        """
 694        return self.return_type
 695
 696    @property
 697    def returns(self) -> list["LocalVariable"]:
 698        """
 699        list(LocalVariable): List of the return variables
 700        """
 701        return list(self._returns)
 702
 703    def add_return(self, r: "LocalVariable") -> None:
 704        self._returns.append(r)
 705
 706    @property
 707    def returns_ssa(self) -> list["LocalIRVariable"]:
 708        """
 709        list(LocalIRVariable): List of the return variables (SSA form)
 710        """
 711        return list(self._returns_ssa)
 712
 713    def add_return_ssa(self, var: "LocalIRVariable") -> None:
 714        self._returns_ssa.append(var)
 715
 716    # endregion
 717    ###################################################################################
 718    ###################################################################################
 719    # region Modifiers
 720    ###################################################################################
 721    ###################################################################################
 722
 723    @property
 724    def modifiers(self) -> list[Union["Contract", "Function"]]:
 725        """
 726        list(Modifier): List of the modifiers
 727        Can be contract for constructor's calls
 728
 729        """
 730        return [c.modifier for c in self._modifiers]
 731
 732    def add_modifier(self, modif: "ModifierStatements") -> None:
 733        self._modifiers.append(modif)
 734
 735    @property
 736    def modifiers_statements(self) -> list[ModifierStatements]:
 737        """
 738        list(ModifierCall): List of the modifiers call (include expression and irs)
 739        """
 740        return list(self._modifiers)
 741
 742    @property
 743    def explicit_base_constructor_calls(self) -> list["Function"]:
 744        """
 745        list(Function): List of the base constructors called explicitly by this presumed constructor definition.
 746
 747                        Base constructors implicitly or explicitly called by the contract definition will not be
 748                        included.
 749        """
 750        # This is a list of contracts internally, so we convert it to a list of constructor functions.
 751        return [
 752            c.modifier.constructors_declared
 753            for c in self._explicit_base_constructor_calls
 754            if c.modifier.constructors_declared
 755        ]
 756
 757    @property
 758    def explicit_base_constructor_calls_statements(self) -> list[ModifierStatements]:
 759        """
 760        list(ModifierCall): List of the base constructors called explicitly by this presumed constructor definition.
 761
 762        """
 763        # This is a list of contracts internally, so we convert it to a list of constructor functions.
 764        return list(self._explicit_base_constructor_calls)
 765
 766    def add_explicit_base_constructor_calls_statements(self, modif: ModifierStatements) -> None:
 767        self._explicit_base_constructor_calls.append(modif)
 768
 769    # endregion
 770    ###################################################################################
 771    ###################################################################################
 772    # region Variables
 773    ###################################################################################
 774    ###################################################################################
 775
 776    @property
 777    def variables(self) -> list[LocalVariable]:
 778        """
 779        Return all local variables
 780        Include parameters and return values
 781        """
 782        return list(self._variables.values())
 783
 784    @property
 785    def local_variables(self) -> list[LocalVariable]:
 786        """
 787        Return all local variables (dont include parameters and return values)
 788        """
 789        return list(set(self.variables) - set(self.returns) - set(self.parameters))
 790
 791    @property
 792    def variables_as_dict(self) -> dict[str, LocalVariable]:
 793        return self._variables
 794
 795    @property
 796    def variables_read(self) -> list["Variable"]:
 797        """
 798        list(Variable): Variables read (local/state/solidity)
 799        """
 800        return list(self._vars_read)
 801
 802    @property
 803    def variables_written(self) -> list["Variable"]:
 804        """
 805        list(Variable): Variables written (local/state/solidity)
 806        """
 807        return list(self._vars_written)
 808
 809    @property
 810    def state_variables_read(self) -> list["StateVariable"]:
 811        """
 812        list(StateVariable): State variables read
 813        """
 814        return list(self._state_vars_read)
 815
 816    @property
 817    def solidity_variables_read(self) -> list["SolidityVariable"]:
 818        """
 819        list(SolidityVariable): Solidity variables read
 820        """
 821        return list(self._solidity_vars_read)
 822
 823    @property
 824    def state_variables_written(self) -> list["StateVariable"]:
 825        """
 826        list(StateVariable): State variables written
 827        """
 828        return list(self._state_vars_written)
 829
 830    @property
 831    def variables_read_or_written(self) -> list["Variable"]:
 832        """
 833        list(Variable): Variables read or written (local/state/solidity)
 834        """
 835        return list(self._vars_read_or_written)
 836
 837    @property
 838    def variables_read_as_expression(self) -> list["Expression"]:
 839        return self._expression_vars_read
 840
 841    @property
 842    def variables_written_as_expression(self) -> list["Expression"]:
 843        return self._expression_vars_written
 844
 845    @property
 846    def slithir_variables(self) -> list["SlithIRVariable"]:
 847        """
 848        Temporary and Reference Variables (not SSA form)
 849        """
 850
 851        return list(self._slithir_variables)
 852
 853    # endregion
 854    ###################################################################################
 855    ###################################################################################
 856    # region Calls
 857    ###################################################################################
 858    ###################################################################################
 859
 860    @property
 861    def internal_calls(self) -> list["InternalCall"]:
 862        """
 863        list(InternalCall): List of IR operations for internal calls
 864        """
 865        return list(self._internal_calls)
 866
 867    @property
 868    def solidity_calls(self) -> list["SolidityCall"]:
 869        """
 870        list(SolidityCall): List of IR operations for Solidity calls
 871        """
 872        return list(self._solidity_calls)
 873
 874    @property
 875    def high_level_calls(self) -> list[tuple["Contract", "HighLevelCall"]]:
 876        """
 877        list(Tuple(Contract, "HighLevelCall")): List of call target contract and IR of the high level call
 878        A variable is called in case of call to a public state variable
 879        Include library calls
 880        """
 881        return list(self._high_level_calls)
 882
 883    @property
 884    def library_calls(self) -> list["LibraryCall"]:
 885        """
 886        list(LibraryCall): List of IR operations for library calls
 887        """
 888        return list(self._library_calls)
 889
 890    @property
 891    def low_level_calls(self) -> list["LowLevelCall"]:
 892        """
 893        list(LowLevelCall): List of IR operations for low level calls
 894        A low level call is defined by
 895        - the variable called
 896        - the name of the function (call/delegatecall/callcode)
 897        """
 898        return list(self._low_level_calls)
 899
 900    @property
 901    def external_calls_as_expressions(self) -> list["Expression"]:
 902        """
 903        list(ExpressionCall): List of message calls (that creates a transaction)
 904        """
 905        return list(self._external_calls_as_expressions)
 906
 907    # endregion
 908    ###################################################################################
 909    ###################################################################################
 910    # region Expressions
 911    ###################################################################################
 912    ###################################################################################
 913
 914    @property
 915    def calls_as_expressions(self) -> list["Expression"]:
 916        return self._expression_calls
 917
 918    @property
 919    def expressions(self) -> list["Expression"]:
 920        """
 921        list(Expression): List of the expressions
 922        """
 923        if self._expressions is None:
 924            expressionss = [n.expression for n in self.nodes]
 925            expressions = [e for e in expressionss if e]
 926            self._expressions = expressions
 927        return self._expressions
 928
 929    @property
 930    def return_values(self) -> list["SlithIRVariable"]:
 931        """
 932        list(Return Values): List of the return values
 933        """
 934        from slither.core.cfg.node import NodeType
 935        from slither.slithir.operations import Return
 936        from slither.slithir.variables import Constant
 937
 938        if self._return_values is None:
 939            return_values = []
 940            returns = [n for n in self.nodes if n.type == NodeType.RETURN]
 941            [
 942                return_values.extend(ir.values)
 943                for node in returns
 944                for ir in node.irs
 945                if isinstance(ir, Return)
 946            ]
 947            self._return_values = list({x for x in return_values if not isinstance(x, Constant)})
 948        return self._return_values
 949
 950    @property
 951    def return_values_ssa(self) -> list["SlithIRVariable"]:
 952        """
 953        list(Return Values in SSA form): List of the return values in ssa form
 954        """
 955        from slither.core.cfg.node import NodeType
 956        from slither.slithir.operations import Return
 957        from slither.slithir.variables import Constant
 958
 959        if self._return_values_ssa is None:
 960            return_values_ssa = []
 961            returns = [n for n in self.nodes if n.type == NodeType.RETURN]
 962            [
 963                return_values_ssa.extend(ir.values)
 964                for node in returns
 965                for ir in node.irs_ssa
 966                if isinstance(ir, Return)
 967            ]
 968            self._return_values_ssa = list(
 969                {x for x in return_values_ssa if not isinstance(x, Constant)}
 970            )
 971        return self._return_values_ssa
 972
 973    # endregion
 974    ###################################################################################
 975    ###################################################################################
 976    # region SlithIR
 977    ###################################################################################
 978    ###################################################################################
 979
 980    @property
 981    def slithir_operations(self) -> list["Operation"]:
 982        """
 983        list(Operation): List of the slithir operations
 984        """
 985        if self._slithir_operations is None:
 986            operationss = [n.irs for n in self.nodes]
 987            operations = [item for sublist in operationss for item in sublist if item]
 988            self._slithir_operations = operations
 989        return self._slithir_operations
 990
 991    @property
 992    def slithir_ssa_operations(self) -> list["Operation"]:
 993        """
 994        list(Operation): List of the slithir operations (SSA)
 995        """
 996        if self._slithir_ssa_operations is None:
 997            operationss = [n.irs_ssa for n in self.nodes]
 998            operations = [item for sublist in operationss for item in sublist if item]
 999            self._slithir_ssa_operations = operations
1000        return self._slithir_ssa_operations
1001
1002    # endregion
1003    ###################################################################################
1004    ###################################################################################
1005    # region Signature
1006    ###################################################################################
1007    ###################################################################################
1008
1009    @property
1010    def solidity_signature(self) -> str:
1011        """
1012        Return a signature following the Solidity Standard
1013        Contract and converted into address
1014
1015        It might still keep internal types (ex: structure name) for internal functions.
1016        The reason is that internal functions allows recursive structure definition, which
1017        can't be converted following the Solidity stand ard
1018
1019        :return: the solidity signature
1020        """
1021        if self._solidity_signature is None:
1022            parameters = [
1023                convert_type_for_solidity_signature_to_string(x.type) for x in self.parameters
1024            ]
1025            self._solidity_signature = self.name + "(" + ",".join(parameters) + ")"
1026        return self._solidity_signature
1027
1028    @property
1029    def signature(self) -> tuple[str, list[str], list[str]]:
1030        """
1031        (str, list(str), list(str)): Function signature as
1032        (name, list parameters type, list return values type)
1033        """
1034        # FIXME memoizing this function is not working properly for vyper
1035        # if self._signature is None:
1036        return (
1037            self.name,
1038            [str(x.type) for x in self.parameters],
1039            [str(x.type) for x in self.returns],
1040        )
1041        #     self._signature = signature
1042        # return self._signature
1043
1044    @property
1045    def signature_str(self) -> str:
1046        """
1047        str: func_name(type1,type2) returns (type3)
1048        Return the function signature as a str (contains the return values)
1049        """
1050        if self._signature_str is None:
1051            name, parameters, returnVars = self.signature
1052            self._signature_str = (
1053                name + "(" + ",".join(parameters) + ") returns(" + ",".join(returnVars) + ")"
1054            )
1055        return self._signature_str
1056
1057    # endregion
1058    ###################################################################################
1059    ###################################################################################
1060    # region Functions
1061    ###################################################################################
1062    ###################################################################################
1063
1064    @property
1065    @abstractmethod
1066    def functions_shadowed(self) -> list["Function"]:
1067        pass
1068
1069    # endregion
1070    ###################################################################################
1071    ###################################################################################
1072    # region Reachable
1073    ###################################################################################
1074    ###################################################################################
1075
1076    @property
1077    def reachable_from_nodes(self) -> set[ReacheableNode]:
1078        """
1079        Return
1080            ReacheableNode
1081        """
1082        return self._reachable_from_nodes
1083
1084    @property
1085    def reachable_from_functions(self) -> set["Function"]:
1086        return self._reachable_from_functions
1087
1088    @property
1089    def all_reachable_from_functions(self) -> set["Function"]:
1090        """
1091        Give the recursive version of reachable_from_functions (all the functions that lead to call self in the CFG)
1092        """
1093        if self._all_reachable_from_functions is None:
1094            functions: set[Function] = set()
1095
1096            new_functions = self.reachable_from_functions
1097            # iterate until we have are finding new functions
1098            while new_functions and not new_functions.issubset(functions):
1099                functions = functions.union(new_functions)
1100                # Use a temporary set, because we iterate over new_functions
1101                new_functionss: set[Function] = set()
1102                for f in new_functions:
1103                    new_functionss = new_functionss.union(f.reachable_from_functions)
1104                new_functions = new_functionss - functions
1105
1106            self._all_reachable_from_functions = functions
1107        return self._all_reachable_from_functions
1108
1109    def add_reachable_from_node(self, n: "Node", ir: "Operation") -> None:
1110        self._reachable_from_nodes.add(ReacheableNode(n, ir))
1111        self._reachable_from_functions.add(n.function)
1112
1113    # endregion
1114    ###################################################################################
1115    ###################################################################################
1116    # region Recursive getters
1117    ###################################################################################
1118    ###################################################################################
1119
1120    def _explore_functions(self, f_new_values: Callable[["Function"], list]) -> list[Any]:
1121        values = f_new_values(self)
1122        explored: set[Function] = {self}
1123        to_explore_set: set[Function] = set()
1124
1125        for ir in self.internal_calls:
1126            if isinstance(ir.function, Function) and ir.function not in explored:
1127                to_explore_set.add(ir.function)
1128        for ir in self.library_calls:
1129            if isinstance(ir.function, Function) and ir.function not in explored:
1130                to_explore_set.add(ir.function)
1131        for m in self.modifiers:
1132            if m not in explored:
1133                to_explore_set.add(m)
1134
1135        while to_explore_set:
1136            f = to_explore_set.pop()
1137            if f in explored:
1138                continue
1139            explored.add(f)
1140
1141            values += f_new_values(f)
1142
1143            for ir in f.internal_calls:
1144                if isinstance(ir.function, Function) and ir.function not in explored:
1145                    to_explore_set.add(ir.function)
1146            for ir in f.library_calls:
1147                if isinstance(ir.function, Function) and ir.function not in explored:
1148                    to_explore_set.add(ir.function)
1149            for m in f.modifiers:
1150                if m not in explored:
1151                    to_explore_set.add(m)
1152
1153        return list(set(values))
1154
1155    def all_variables_read(self) -> list["Variable"]:
1156        """recursive version of variables_read"""
1157        if self._all_variables_read is None:
1158            self._all_variables_read = self._explore_functions(lambda x: x.variables_read)
1159        return self._all_variables_read
1160
1161    def all_variables_written(self) -> list["Variable"]:
1162        """recursive version of variables_written"""
1163        if self._all_variables_written is None:
1164            self._all_variables_written = self._explore_functions(lambda x: x.variables_written)
1165        return self._all_variables_written
1166
1167    def all_state_variables_read(self) -> list["StateVariable"]:
1168        """recursive version of variables_read"""
1169        if self._all_state_variables_read is None:
1170            self._all_state_variables_read = self._explore_functions(
1171                lambda x: x.state_variables_read
1172            )
1173        return self._all_state_variables_read
1174
1175    def all_solidity_variables_read(self) -> list[SolidityVariable]:
1176        """recursive version of solidity_read"""
1177        if self._all_solidity_variables_read is None:
1178            self._all_solidity_variables_read = self._explore_functions(
1179                lambda x: x.solidity_variables_read
1180            )
1181        return self._all_solidity_variables_read
1182
1183    def all_slithir_variables(self) -> list["SlithIRVariable"]:
1184        """recursive version of slithir_variables"""
1185        if self._all_slithir_variables is None:
1186            self._all_slithir_variables = self._explore_functions(lambda x: x.slithir_variables)
1187        return self._all_slithir_variables
1188
1189    def all_nodes(self) -> list["Node"]:
1190        """recursive version of nodes"""
1191        if self._all_nodes is None:
1192            self._all_nodes = self._explore_functions(lambda x: x.nodes)
1193        return self._all_nodes
1194
1195    def all_expressions(self) -> list["Expression"]:
1196        """recursive version of variables_read"""
1197        if self._all_expressions is None:
1198            self._all_expressions = self._explore_functions(lambda x: x.expressions)
1199        return self._all_expressions
1200
1201    def all_slithir_operations(self) -> list["Operation"]:
1202        if self._all_slithir_operations is None:
1203            self._all_slithir_operations = self._explore_functions(lambda x: x.slithir_operations)
1204        return self._all_slithir_operations
1205
1206    def all_state_variables_written(self) -> list[StateVariable]:
1207        """recursive version of variables_written"""
1208        if self._all_state_variables_written is None:
1209            self._all_state_variables_written = self._explore_functions(
1210                lambda x: x.state_variables_written
1211            )
1212        return self._all_state_variables_written
1213
1214    def all_internal_calls(self) -> list["InternalCall"]:
1215        """recursive version of internal_calls"""
1216        if self._all_internals_calls is None:
1217            self._all_internals_calls = self._explore_functions(lambda x: x.internal_calls)
1218        return self._all_internals_calls
1219
1220    def all_low_level_calls(self) -> list["LowLevelCall"]:
1221        """recursive version of low_level calls"""
1222        if self._all_low_level_calls is None:
1223            self._all_low_level_calls = self._explore_functions(lambda x: x.low_level_calls)
1224        return self._all_low_level_calls
1225
1226    def all_high_level_calls(self) -> list[tuple["Contract", "HighLevelCall"]]:
1227        """recursive version of high_level calls"""
1228        if self._all_high_level_calls is None:
1229            self._all_high_level_calls = self._explore_functions(lambda x: x.high_level_calls)
1230        return self._all_high_level_calls
1231
1232    def all_library_calls(self) -> list["LibraryCall"]:
1233        """recursive version of library calls"""
1234        if self._all_library_calls is None:
1235            self._all_library_calls = self._explore_functions(lambda x: x.library_calls)
1236        return self._all_library_calls
1237
1238    def all_solidity_calls(self) -> list["SolidityCall"]:
1239        """recursive version of solidity calls"""
1240        if self._all_solidity_calls is None:
1241            self._all_solidity_calls = self._explore_functions(lambda x: x.solidity_calls)
1242        return self._all_solidity_calls
1243
1244    @staticmethod
1245    def _explore_func_cond_read(func: "Function", include_loop: bool) -> list["StateVariable"]:
1246        ret = [n.state_variables_read for n in func.nodes if n.is_conditional(include_loop)]
1247        return [item for sublist in ret for item in sublist]
1248
1249    def all_conditional_state_variables_read(self, include_loop=True) -> list["StateVariable"]:
1250        """
1251        Return the state variable used in a condition
1252
1253        Over approximate and also return index access
1254        It won't work if the variable is assigned to a temp variable
1255        """
1256        if include_loop:
1257            if self._all_conditional_state_variables_read_with_loop is None:
1258                self._all_conditional_state_variables_read_with_loop = self._explore_functions(
1259                    lambda x: self._explore_func_cond_read(x, include_loop)
1260                )
1261            return self._all_conditional_state_variables_read_with_loop
1262        if self._all_conditional_state_variables_read is None:
1263            self._all_conditional_state_variables_read = self._explore_functions(
1264                lambda x: self._explore_func_cond_read(x, include_loop)
1265            )
1266        return self._all_conditional_state_variables_read
1267
1268    @staticmethod
1269    def _solidity_variable_in_binary(node: "Node") -> list[SolidityVariable]:
1270        from slither.slithir.operations.binary import Binary
1271
1272        ret = []
1273        for ir in node.irs:
1274            if isinstance(ir, Binary):
1275                ret += ir.read
1276        return [var for var in ret if isinstance(var, SolidityVariable)]
1277
1278    @staticmethod
1279    def _explore_func_conditional(
1280        func: "Function",
1281        f: Callable[["Node"], list[SolidityVariable]],
1282        include_loop: bool,
1283    ) -> list[Any]:
1284        ret = [f(n) for n in func.nodes if n.is_conditional(include_loop)]
1285        return [item for sublist in ret for item in sublist]
1286
1287    def all_conditional_solidity_variables_read(
1288        self, include_loop: bool = True
1289    ) -> list[SolidityVariable]:
1290        """
1291        Return the Solidity variables directly used in a condition
1292
1293        Use of the IR to filter index access
1294        Assumption: the solidity vars are used directly in the conditional node
1295        It won't work if the variable is assigned to a temp variable
1296        """
1297        if include_loop:
1298            if self._all_conditional_solidity_variables_read_with_loop is None:
1299                self._all_conditional_solidity_variables_read_with_loop = self._explore_functions(
1300                    lambda x: self._explore_func_conditional(
1301                        x, self._solidity_variable_in_binary, include_loop
1302                    )
1303                )
1304            return self._all_conditional_solidity_variables_read_with_loop
1305
1306        if self._all_conditional_solidity_variables_read is None:
1307            self._all_conditional_solidity_variables_read = self._explore_functions(
1308                lambda x: self._explore_func_conditional(
1309                    x, self._solidity_variable_in_binary, include_loop
1310                )
1311            )
1312        return self._all_conditional_solidity_variables_read
1313
1314    @staticmethod
1315    def _solidity_variable_in_internal_calls(node: "Node") -> list[SolidityVariable]:
1316        from slither.slithir.operations.internal_call import InternalCall
1317
1318        ret = []
1319        for ir in node.irs:
1320            if isinstance(ir, InternalCall):
1321                ret += ir.read
1322        return [var for var in ret if isinstance(var, SolidityVariable)]
1323
1324    @staticmethod
1325    def _explore_func_nodes(
1326        func: "Function", f: Callable[["Node"], list[SolidityVariable]]
1327    ) -> list[Any | SolidityVariableComposed]:
1328        ret = [f(n) for n in func.nodes]
1329        return [item for sublist in ret for item in sublist]
1330
1331    def all_solidity_variables_used_as_args(self) -> list[SolidityVariable]:
1332        """
1333        Return the Solidity variables directly used in a call
1334
1335        Use of the IR to filter index access
1336        Used to catch check(msg.sender)
1337        """
1338        if self._all_solidity_variables_used_as_args is None:
1339            self._all_solidity_variables_used_as_args = self._explore_functions(
1340                lambda x: self._explore_func_nodes(x, self._solidity_variable_in_internal_calls)
1341            )
1342        return self._all_solidity_variables_used_as_args
1343
1344    # endregion
1345    ###################################################################################
1346    ###################################################################################
1347    # region Visitor
1348    ###################################################################################
1349    ###################################################################################
1350
1351    def apply_visitor(self, Visitor: Callable) -> list:
1352        """
1353            Apply a visitor to all the function expressions
1354        Args:
1355            Visitor: slither.visitors
1356        Returns
1357            list(): results of the visit
1358        """
1359        expressions = self.expressions
1360        v = [Visitor(e).result() for e in expressions]
1361        return [item for sublist in v for item in sublist]
1362
1363    # endregion
1364    ###################################################################################
1365    ###################################################################################
1366    # region Getters from/to object
1367    ###################################################################################
1368    ###################################################################################
1369
1370    def get_local_variable_from_name(self, variable_name: str) -> LocalVariable | None:
1371        """
1372            Return a local variable from a name
1373
1374        Args:
1375            variable_name (str): name of the variable
1376        Returns:
1377            LocalVariable
1378        """
1379        return next((v for v in self.variables if v.name == variable_name), None)
1380
1381    # endregion
1382    ###################################################################################
1383    ###################################################################################
1384    # region Export
1385    ###################################################################################
1386    ###################################################################################
1387
1388    def cfg_to_dot(self, filename: str):
1389        """
1390            Export the function to a dot file
1391        Args:
1392            filename (str)
1393        """
1394        with open(filename, "w", encoding="utf8") as f:
1395            f.write("digraph{\n")
1396            for node in self.nodes:
1397                f.write(f'{node.node_id}[label="{node!s}"];\n')
1398                for son in node.sons:
1399                    f.write(f"{node.node_id}->{son.node_id};\n")
1400
1401            f.write("}\n")
1402
1403    def dominator_tree_to_dot(self, filename: str):
1404        """
1405            Export the dominator tree of the function to a dot file
1406        Args:
1407            filename (str)
1408        """
1409
1410        def description(node):
1411            desc = f"{node}\n"
1412            desc += f"id: {node.node_id}"
1413            if node.dominance_frontier:
1414                desc += f"\ndominance frontier: {[n.node_id for n in node.dominance_frontier]}"
1415            return desc
1416
1417        with open(filename, "w", encoding="utf8") as f:
1418            f.write("digraph{\n")
1419            for node in self.nodes:
1420                f.write(f'{node.node_id}[label="{description(node)}"];\n')
1421                if node.immediate_dominator:
1422                    f.write(f"{node.immediate_dominator.node_id}->{node.node_id};\n")
1423
1424            f.write("}\n")
1425
1426    def slithir_cfg_to_dot(self, filename: str):
1427        """
1428        Export the CFG to a DOT file. The nodes includes the Solidity expressions and the IRs
1429        :param filename:
1430        :return:
1431        """
1432        content = self.slithir_cfg_to_dot_str()
1433        with open(filename, "w", encoding="utf8") as f:
1434            f.write(content)
1435
1436    def slithir_cfg_to_dot_str(self, skip_expressions: bool = False) -> str:
1437        """
1438        Export the CFG to a DOT format. The nodes includes the Solidity expressions and the IRs
1439        :return: the DOT content
1440        :rtype: str
1441        """
1442        from slither.core.cfg.node import NodeType
1443
1444        content = ""
1445        content += "digraph{\n"
1446        for node in self.nodes:
1447            label = f"Node Type: {node.type.value} {node.node_id}\n"
1448            if node.expression and not skip_expressions:
1449                label += f"\nEXPRESSION:\n{node.expression}\n"
1450            if node.irs and not skip_expressions:
1451                label += "\nIRs:\n" + "\n".join([str(ir) for ir in node.irs])
1452            content += f'{node.node_id}[label="{label}"];\n'
1453            if node.type in [NodeType.IF, NodeType.IFLOOP]:
1454                true_node = node.son_true
1455                if true_node:
1456                    content += f'{node.node_id}->{true_node.node_id}[label="True"];\n'
1457                false_node = node.son_false
1458                if false_node:
1459                    content += f'{node.node_id}->{false_node.node_id}[label="False"];\n'
1460            else:
1461                for son in node.sons:
1462                    content += f"{node.node_id}->{son.node_id};\n"
1463
1464        content += "}\n"
1465        return content
1466
1467    # endregion
1468    ###################################################################################
1469    ###################################################################################
1470    # region Summary information
1471    ###################################################################################
1472    ###################################################################################
1473
1474    def is_reading(self, variable: "Variable") -> bool:
1475        """
1476            Check if the function reads the variable
1477        Args:
1478            variable (Variable):
1479        Returns:
1480            bool: True if the variable is read
1481        """
1482        return variable in self.variables_read
1483
1484    def is_reading_in_conditional_node(self, variable: "Variable") -> bool:
1485        """
1486            Check if the function reads the variable in a IF node
1487        Args:
1488            variable (Variable):
1489        Returns:
1490            bool: True if the variable is read
1491        """
1492        variables_reads = [n.variables_read for n in self.nodes if n.contains_if()]
1493        variables_read = [item for sublist in variables_reads for item in sublist]
1494        return variable in variables_read
1495
1496    def is_reading_in_require_or_assert(self, variable: "Variable") -> bool:
1497        """
1498            Check if the function reads the variable in an require or assert
1499        Args:
1500            variable (Variable):
1501        Returns:
1502            bool: True if the variable is read
1503        """
1504        variables_reads = [n.variables_read for n in self.nodes if n.contains_require_or_assert()]
1505        variables_read = [item for sublist in variables_reads for item in sublist]
1506        return variable in variables_read
1507
1508    def is_writing(self, variable: "Variable") -> bool:
1509        """
1510            Check if the function writes the variable
1511        Args:
1512            variable (Variable):
1513        Returns:
1514            bool: True if the variable is written
1515        """
1516        return variable in self.variables_written
1517
1518    @abstractmethod
1519    def get_summary(
1520        self,
1521    ) -> tuple[str, str, str, list[str], list[str], list[str], list[str], list[str]]:
1522        pass
1523
1524    def is_protected(self) -> bool:
1525        """
1526            Determine if the function is protected using a check on msg.sender
1527
1528            Consider onlyOwner as a safe modifier.
1529            If the owner functionality is incorrectly implemented, this will lead to incorrectly
1530            classify the function as protected
1531
1532            Otherwise only detects if msg.sender is directly used in a condition
1533            For example, it wont work for:
1534                address a = msg.sender
1535                require(a == owner)
1536        Returns
1537            (bool)
1538        """
1539
1540        if self._is_protected is None:
1541            if self.is_constructor:
1542                self._is_protected = True
1543                return True
1544            if "onlyOwner" in [m.name for m in self.modifiers]:
1545                self._is_protected = True
1546                return True
1547            conditional_vars = self.all_conditional_solidity_variables_read(include_loop=False)
1548            args_vars = self.all_solidity_variables_used_as_args()
1549            self._is_protected = (
1550                SolidityVariableComposed("msg.sender") in conditional_vars + args_vars
1551            )
1552        return self._is_protected
1553
1554    @property
1555    def is_reentrant(self) -> bool:
1556        """
1557        Determine if the function can be re-entered
1558        """
1559        reentrancy_modifier = "nonReentrant"
1560
1561        if self.function_language == FunctionLanguage.Vyper:
1562            reentrancy_modifier = "nonreentrant(lock)"
1563
1564        # TODO: compare with hash of known nonReentrant modifier instead of the name
1565        if reentrancy_modifier in [m.name for m in self.modifiers]:
1566            return False
1567
1568        if self.visibility in ["public", "external"]:
1569            return True
1570
1571        # If it's an internal function, check if all its entry points have the nonReentrant modifier
1572        all_entry_points = [
1573            f for f in self.all_reachable_from_functions if f.visibility in ["public", "external"]
1574        ]
1575        if not all_entry_points:
1576            return True
1577        return not all(
1578            reentrancy_modifier in [m.name for m in f.modifiers] for f in all_entry_points
1579        )
1580
1581    # endregion
1582    ###################################################################################
1583    ###################################################################################
1584    # region Analyses
1585    ###################################################################################
1586    ###################################################################################
1587
1588    def _analyze_read_write(self) -> None:
1589        """Compute variables read/written/..."""
1590        write_var = [x.variables_written_as_expression for x in self.nodes]
1591        write_var = [x for x in write_var if x]
1592        write_var = [item for sublist in write_var for item in sublist]
1593        write_var = list(set(write_var))
1594        # Remove duplicate if they share the same string representation
1595        write_var = [
1596            next(obj)
1597            for i, obj in groupby(sorted(write_var, key=lambda x: str(x)), lambda x: str(x))
1598        ]
1599        self._expression_vars_written = write_var
1600
1601        write_var = [x.variables_written for x in self.nodes]
1602        write_var = [x for x in write_var if x]
1603        write_var = [item for sublist in write_var for item in sublist]
1604        write_var = list(set(write_var))
1605        # Remove duplicate if they share the same string representation
1606        write_var = [
1607            next(obj)
1608            for i, obj in groupby(sorted(write_var, key=lambda x: str(x)), lambda x: str(x))
1609        ]
1610        self._vars_written = write_var
1611
1612        read_var = [x.variables_read_as_expression for x in self.nodes]
1613        read_var = [x for x in read_var if x]
1614        read_var = [item for sublist in read_var for item in sublist]
1615        # Remove duplicate if they share the same string representation
1616        read_var = [
1617            next(obj)
1618            for i, obj in groupby(sorted(read_var, key=lambda x: str(x)), lambda x: str(x))
1619        ]
1620        self._expression_vars_read = read_var
1621
1622        read_var = [x.variables_read for x in self.nodes]
1623        read_var = [x for x in read_var if x]
1624        read_var = [item for sublist in read_var for item in sublist]
1625        # Remove duplicate if they share the same string representation
1626        read_var = [
1627            next(obj)
1628            for i, obj in groupby(sorted(read_var, key=lambda x: str(x)), lambda x: str(x))
1629        ]
1630        self._vars_read = read_var
1631
1632        self._state_vars_written = [
1633            x for x in self.variables_written if isinstance(x, StateVariable)
1634        ]
1635        self._state_vars_read = [x for x in self.variables_read if isinstance(x, StateVariable)]
1636        self._solidity_vars_read = [
1637            x for x in self.variables_read if isinstance(x, SolidityVariable)
1638        ]
1639
1640        self._vars_read_or_written = self._vars_written + self._vars_read
1641
1642        slithir_variables = [x.slithir_variables for x in self.nodes]
1643        slithir_variables = [x for x in slithir_variables if x]
1644        self._slithir_variables = [item for sublist in slithir_variables for item in sublist]
1645
1646    def _analyze_calls(self) -> None:
1647        calls = [x.calls_as_expression for x in self.nodes]
1648        calls = [x for x in calls if x]
1649        calls = [item for sublist in calls for item in sublist]
1650        self._expression_calls = list(set(calls))
1651
1652        internal_calls = [x.internal_calls for x in self.nodes]
1653        internal_calls = [x for x in internal_calls if x]
1654        internal_calls = [item for sublist in internal_calls for item in sublist]
1655        self._internal_calls = list(set(internal_calls))
1656
1657        self._solidity_calls = [
1658            ir for ir in internal_calls if isinstance(ir.function, SolidityFunction)
1659        ]
1660
1661        low_level_calls = [x.low_level_calls for x in self.nodes]
1662        low_level_calls = [x for x in low_level_calls if x]
1663        low_level_calls = [item for sublist in low_level_calls for item in sublist]
1664        self._low_level_calls = list(set(low_level_calls))
1665
1666        high_level_calls = [x.high_level_calls for x in self.nodes]
1667        high_level_calls = [x for x in high_level_calls if x]
1668        high_level_calls = [item for sublist in high_level_calls for item in sublist]
1669        self._high_level_calls = list(set(high_level_calls))
1670
1671        library_calls = [x.library_calls for x in self.nodes]
1672        library_calls = [x for x in library_calls if x]
1673        library_calls = [item for sublist in library_calls for item in sublist]
1674        self._library_calls = list(set(library_calls))
1675
1676        external_calls_as_expressions = [x.external_calls_as_expressions for x in self.nodes]
1677        external_calls_as_expressions = [x for x in external_calls_as_expressions if x]
1678        external_calls_as_expressions = [
1679            item for sublist in external_calls_as_expressions for item in sublist
1680        ]
1681        self._external_calls_as_expressions = list(set(external_calls_as_expressions))
1682
1683    # endregion
1684    ###################################################################################
1685    ###################################################################################
1686    # region Nodes
1687    ###################################################################################
1688    ###################################################################################
1689
1690    def new_node(
1691        self, node_type: "NodeType", src: str | dict, scope: Union[Scope, "Function"]
1692    ) -> "Node":
1693        from slither.core.cfg.node import Node
1694
1695        node = Node(node_type, self._counter_nodes, scope, self.file_scope)
1696        node.set_offset(src, self.compilation_unit)
1697        self._counter_nodes += 1
1698        node.set_function(self)
1699        self._nodes.append(node)
1700
1701        return node
1702
1703    # endregion
1704    ###################################################################################
1705    ###################################################################################
1706    # region SlithIr and SSA
1707    ###################################################################################
1708    ###################################################################################
1709
1710    def _get_last_ssa_variable_instances(
1711        self, target_state: bool, target_local: bool
1712    ) -> dict[str, set["SlithIRVariable"]]:
1713        from slither.slithir.variables import ReferenceVariable
1714        from slither.slithir.operations import OperationWithLValue
1715        from slither.core.cfg.node import NodeType
1716
1717        if not self.is_implemented:
1718            return {}
1719
1720        if self._entry_point is None:
1721            return {}
1722        # node, values
1723        to_explore: list[tuple[Node, dict]] = [(self._entry_point, {})]
1724        # node -> values
1725        explored: dict = {}
1726        # name -> instances
1727        ret: dict = {}
1728
1729        while to_explore:
1730            node, values = to_explore[0]
1731            to_explore = to_explore[1::]
1732
1733            if node.type != NodeType.ENTRYPOINT:
1734                for ir_ssa in node.irs_ssa:
1735                    if isinstance(ir_ssa, OperationWithLValue):
1736                        lvalue = ir_ssa.lvalue
1737                        if isinstance(lvalue, ReferenceVariable):
1738                            lvalue = lvalue.points_to_origin
1739                        if isinstance(lvalue, StateVariable) and target_state:
1740                            values[lvalue.canonical_name] = {lvalue}
1741                        if isinstance(lvalue, LocalVariable) and target_local:
1742                            values[lvalue.canonical_name] = {lvalue}
1743
1744            # Check for fixpoint
1745            if node in explored:
1746                if values == explored[node]:
1747                    continue
1748                for k, instances in values.items():
1749                    if k not in explored[node]:
1750                        explored[node][k] = set()
1751                    explored[node][k] |= instances
1752                values = explored[node]
1753            else:
1754                explored[node] = values
1755
1756            # Return condition
1757            if node.will_return:
1758                for name, instances in values.items():
1759                    if name not in ret:
1760                        ret[name] = set()
1761                    ret[name] |= instances
1762
1763            for son in node.sons:
1764                to_explore.append((son, dict(values)))
1765
1766        return ret
1767
1768    def get_last_ssa_state_variables_instances(
1769        self,
1770    ) -> dict[str, set["SlithIRVariable"]]:
1771        return self._get_last_ssa_variable_instances(target_state=True, target_local=False)
1772
1773    def get_last_ssa_local_variables_instances(
1774        self,
1775    ) -> dict[str, set["SlithIRVariable"]]:
1776        return self._get_last_ssa_variable_instances(target_state=False, target_local=True)
1777
1778    @staticmethod
1779    def _unchange_phi(ir: "Operation") -> bool:
1780        from slither.slithir.operations import Phi, PhiCallback
1781
1782        if not isinstance(ir, (Phi, PhiCallback)) or len(ir.rvalues) > 1:
1783            return False
1784        if not ir.rvalues:
1785            return True
1786        return ir.rvalues[0] == ir.lvalue
1787
1788    def _fix_phi_entry(
1789        self,
1790        node: "Node",
1791        last_state_variables_instances: dict[str, list["StateVariable"]],
1792        initial_state_variables_instances: dict[str, "StateVariable"],
1793    ) -> None:
1794        from slither.slithir.variables import Constant, StateIRVariable, LocalIRVariable
1795
1796        for ir in node.irs_ssa:
1797            if isinstance(ir.lvalue, StateIRVariable):
1798                additional = [initial_state_variables_instances[ir.lvalue.canonical_name]]
1799                additional += last_state_variables_instances[ir.lvalue.canonical_name]
1800                ir.rvalues = list(set(additional + ir.rvalues))
1801            # function parameter that are storage pointer
1802            else:
1803                # find index of the parameter
1804                idx = self.parameters.index(ir.lvalue.non_ssa_version)
1805                # find non ssa version of that index
1806                additional = [n.ir.arguments[idx] for n in self.reachable_from_nodes]
1807                additional = unroll(additional)
1808                additional = [a for a in additional if not isinstance(a, Constant)]
1809                ir.rvalues = list(set(additional + ir.rvalues))
1810
1811                if isinstance(ir.lvalue, LocalIRVariable) and ir.lvalue.is_storage:
1812                    # Update the refers_to to point to the phi rvalues
1813                    # This basically means that the local variable is a storage that point to any
1814                    # state variable that the storage pointer alias analysis found
1815                    ir.lvalue.refers_to = [
1816                        rvalue for rvalue in ir.rvalues if isinstance(rvalue, StateIRVariable)
1817                    ]
1818
1819    def fix_phi(
1820        self,
1821        last_state_variables_instances: dict[str, list["StateVariable"]],
1822        initial_state_variables_instances: dict[str, "StateVariable"],
1823    ) -> None:
1824        from slither.slithir.operations import InternalCall, PhiCallback, Phi
1825        from slither.slithir.variables import StateIRVariable, LocalIRVariable
1826
1827        for node in self.nodes:
1828            if node == self.entry_point:
1829                self._fix_phi_entry(
1830                    node, last_state_variables_instances, initial_state_variables_instances
1831                )
1832            for ir in node.irs_ssa:
1833                if isinstance(ir, PhiCallback):
1834                    callee_ir = ir.callee_ir
1835                    if isinstance(callee_ir, InternalCall):
1836                        last_ssa = callee_ir.function.get_last_ssa_state_variables_instances()
1837                        if ir.lvalue.canonical_name in last_ssa:
1838                            ir.rvalues = list(last_ssa[ir.lvalue.canonical_name])
1839                        else:
1840                            ir.rvalues = [ir.lvalue]
1841                    else:
1842                        additional = last_state_variables_instances[ir.lvalue.canonical_name]
1843                        ir.rvalues = list(set(additional + ir.rvalues))
1844
1845                # Propage storage ref information if it does not exist
1846                # This can happen if the refers_to variable was discovered through the phi operator on function parameter
1847                # aka you have storage pointer as function parameter
1848                # instead of having a storage pointer for which the aliases belong to the function body
1849                if (
1850                    isinstance(ir, Phi)
1851                    and isinstance(ir.lvalue, LocalIRVariable)
1852                    and ir.lvalue.is_storage
1853                    and not ir.lvalue.refers_to
1854                ):
1855                    refers_to = []
1856                    for candidate in ir.rvalues:
1857                        if isinstance(candidate, StateIRVariable):
1858                            refers_to.append(candidate)
1859                        if isinstance(candidate, LocalIRVariable) and candidate.is_storage:
1860                            refers_to += candidate.refers_to
1861
1862                    ir.lvalue.refers_to = refers_to
1863
1864            node.irs_ssa = [ir for ir in node.irs_ssa if not self._unchange_phi(ir)]
1865
1866    def generate_slithir_and_analyze(self) -> None:
1867        for node in self.nodes:
1868            node.slithir_generation()
1869
1870        self._analyze_read_write()
1871        self._analyze_calls()
1872
1873    @abstractmethod
1874    def generate_slithir_ssa(self, all_ssa_state_variables_instances):
1875        pass
1876
1877    def update_read_write_using_ssa(self) -> None:
1878        for node in self.nodes:
1879            node.update_read_write_using_ssa()
1880        self._analyze_read_write()
1881
1882    ###################################################################################
1883    ###################################################################################
1884    # region Built in definitions
1885    ###################################################################################
1886    ###################################################################################
1887
1888    def __str__(self) -> str:
1889        return self.name
1890
1891    # endregion