slither.core.declarations.function

   1"""
   2    Function module
   3"""
   4import logging
   5from abc import abstractmethod, ABCMeta
   6from collections import namedtuple
   7from enum import Enum
   8from itertools import groupby
   9from typing import Any, Dict, TYPE_CHECKING, List, Optional, Set, Union, Callable, Tuple
  10
  11from slither.core.cfg.scope import Scope
  12from slither.core.declarations.solidity_variables import (
  13    SolidityFunction,
  14    SolidityVariable,
  15    SolidityVariableComposed,
  16)
  17from slither.core.expressions import (
  18    Identifier,
  19    IndexAccess,
  20    MemberAccess,
  21    UnaryOperation,
  22)
  23from slither.core.solidity_types.type import Type
  24from slither.core.source_mapping.source_mapping import SourceMapping
  25from slither.core.variables.local_variable import LocalVariable
  26from slither.core.variables.state_variable import StateVariable
  27from slither.utils.type import convert_type_for_solidity_signature_to_string
  28from slither.utils.utils import unroll
  29
  30
  31# pylint: disable=import-outside-toplevel,too-many-instance-attributes,too-many-statements,too-many-lines
  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):  # pylint: disable=too-many-public-methods
 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: Optional[str] = None
 122        self._view: bool = False
 123        self._pure: bool = False
 124        self._payable: bool = False
 125        self._visibility: Optional[str] = None
 126        self._virtual: bool = False
 127        self._overrides: List["FunctionContract"] = []
 128        self._overridden_by: List["FunctionContract"] = []
 129
 130        self._is_implemented: Optional[bool] = None
 131        self._is_empty: Optional[bool] = None
 132        self._entry_point: Optional["Node"] = 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: Optional[List["SlithIRVariable"]] = None
 146        self._return_values_ssa: Optional[List["SlithIRVariable"]] = 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: Optional[List["Expression"]] = None
 168        self._slithir_operations: Optional[List["Operation"]] = None
 169        self._slithir_ssa_operations: Optional[List["Operation"]] = None
 170
 171        self._all_expressions: Optional[List["Expression"]] = None
 172        self._all_slithir_operations: Optional[List["Operation"]] = None
 173        self._all_internals_calls: Optional[List["InternalCall"]] = None
 174        self._all_high_level_calls: Optional[List[Tuple["Contract", "HighLevelCall"]]] = None
 175        self._all_library_calls: Optional[List["LibraryCall"]] = None
 176        self._all_low_level_calls: Optional[List["LowLevelCall"]] = None
 177        self._all_solidity_calls: Optional[List["SolidityCall"]] = None
 178        self._all_variables_read: Optional[List["Variable"]] = None
 179        self._all_variables_written: Optional[List["Variable"]] = None
 180        self._all_state_variables_read: Optional[List["StateVariable"]] = None
 181        self._all_solidity_variables_read: Optional[List["SolidityVariable"]] = None
 182        self._all_state_variables_written: Optional[List["StateVariable"]] = None
 183        self._all_slithir_variables: Optional[List["SlithIRVariable"]] = None
 184        self._all_nodes: Optional[List["Node"]] = None
 185        self._all_conditional_state_variables_read: Optional[List["StateVariable"]] = None
 186        self._all_conditional_state_variables_read_with_loop: Optional[List["StateVariable"]] = None
 187        self._all_conditional_solidity_variables_read: Optional[List["SolidityVariable"]] = None
 188        self._all_conditional_solidity_variables_read_with_loop: Optional[
 189            List["SolidityVariable"]
 190        ] = None
 191        self._all_solidity_variables_used_as_args: Optional[List["SolidityVariable"]] = 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: Optional[Set[Function]] = None
 200
 201        # Constructor, fallback, State variable constructor
 202        self._function_type: Optional[FunctionType] = None
 203        self._is_constructor: Optional[bool] = None
 204
 205        # Computed on the fly, can be True of False
 206        self._can_reenter: Optional[bool] = None
 207        self._can_send_eth: Optional[bool] = None
 208
 209        self._nodes_ordered_dominators: Optional[List["Node"]] = 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: Optional[str] = None
 216        self._signature: Optional[Tuple[str, List[str], List[str]]] = None
 217        self._solidity_signature: Optional[str] = None
 218        self._signature_str: Optional[str] = None
 219        self._canonical_name: Optional[str] = None
 220        self._is_protected: Optional[bool] = 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: Optional[str] = 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: Optional[List[Union["Function", "Variable"]]] = 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) -> Optional[str]:
 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) -> Optional[FunctionType]:
 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 not node 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) -> Optional[List[Type]]:
 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) -> Optional[List[Type]]:
 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            [  # pylint: disable=expression-not-assigned
 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            [  # pylint: disable=expression-not-assigned
 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 = [self]
1123        to_explore = [
1124            ir.function
1125            for ir in self.internal_calls
1126            if isinstance(ir.function, Function) and ir.function not in explored
1127        ]
1128        to_explore += [
1129            ir.function
1130            for ir in self.library_calls
1131            if isinstance(ir.function, Function) and ir.function not in explored
1132        ]
1133        to_explore += [m for m in self.modifiers if m not in explored]
1134
1135        while to_explore:
1136            f = to_explore[0]
1137            to_explore = to_explore[1:]
1138            if f in explored:
1139                continue
1140            explored.append(f)
1141
1142            values += f_new_values(f)
1143
1144            to_explore += [
1145                ir.function
1146                for ir in f.internal_calls
1147                if isinstance(ir.function, Function)
1148                and ir.function not in explored
1149                and ir.function not in to_explore
1150            ]
1151            to_explore += [
1152                ir.function
1153                for ir in f.library_calls
1154                if isinstance(ir.function, Function)
1155                and ir.function not in explored
1156                and ir.function not in to_explore
1157            ]
1158            to_explore += [m for m in f.modifiers if m not in explored and m not in to_explore]
1159
1160        return list(set(values))
1161
1162    def all_variables_read(self) -> List["Variable"]:
1163        """recursive version of variables_read"""
1164        if self._all_variables_read is None:
1165            self._all_variables_read = self._explore_functions(lambda x: x.variables_read)
1166        return self._all_variables_read
1167
1168    def all_variables_written(self) -> List["Variable"]:
1169        """recursive version of variables_written"""
1170        if self._all_variables_written is None:
1171            self._all_variables_written = self._explore_functions(lambda x: x.variables_written)
1172        return self._all_variables_written
1173
1174    def all_state_variables_read(self) -> List["StateVariable"]:
1175        """recursive version of variables_read"""
1176        if self._all_state_variables_read is None:
1177            self._all_state_variables_read = self._explore_functions(
1178                lambda x: x.state_variables_read
1179            )
1180        return self._all_state_variables_read
1181
1182    def all_solidity_variables_read(self) -> List[SolidityVariable]:
1183        """recursive version of solidity_read"""
1184        if self._all_solidity_variables_read is None:
1185            self._all_solidity_variables_read = self._explore_functions(
1186                lambda x: x.solidity_variables_read
1187            )
1188        return self._all_solidity_variables_read
1189
1190    def all_slithir_variables(self) -> List["SlithIRVariable"]:
1191        """recursive version of slithir_variables"""
1192        if self._all_slithir_variables is None:
1193            self._all_slithir_variables = self._explore_functions(lambda x: x.slithir_variables)
1194        return self._all_slithir_variables
1195
1196    def all_nodes(self) -> List["Node"]:
1197        """recursive version of nodes"""
1198        if self._all_nodes is None:
1199            self._all_nodes = self._explore_functions(lambda x: x.nodes)
1200        return self._all_nodes
1201
1202    def all_expressions(self) -> List["Expression"]:
1203        """recursive version of variables_read"""
1204        if self._all_expressions is None:
1205            self._all_expressions = self._explore_functions(lambda x: x.expressions)
1206        return self._all_expressions
1207
1208    def all_slithir_operations(self) -> List["Operation"]:
1209        if self._all_slithir_operations is None:
1210            self._all_slithir_operations = self._explore_functions(lambda x: x.slithir_operations)
1211        return self._all_slithir_operations
1212
1213    def all_state_variables_written(self) -> List[StateVariable]:
1214        """recursive version of variables_written"""
1215        if self._all_state_variables_written is None:
1216            self._all_state_variables_written = self._explore_functions(
1217                lambda x: x.state_variables_written
1218            )
1219        return self._all_state_variables_written
1220
1221    def all_internal_calls(self) -> List["InternalCall"]:
1222        """recursive version of internal_calls"""
1223        if self._all_internals_calls is None:
1224            self._all_internals_calls = self._explore_functions(lambda x: x.internal_calls)
1225        return self._all_internals_calls
1226
1227    def all_low_level_calls(self) -> List["LowLevelCall"]:
1228        """recursive version of low_level calls"""
1229        if self._all_low_level_calls is None:
1230            self._all_low_level_calls = self._explore_functions(lambda x: x.low_level_calls)
1231        return self._all_low_level_calls
1232
1233    def all_high_level_calls(self) -> List[Tuple["Contract", "HighLevelCall"]]:
1234        """recursive version of high_level calls"""
1235        if self._all_high_level_calls is None:
1236            self._all_high_level_calls = self._explore_functions(lambda x: x.high_level_calls)
1237        return self._all_high_level_calls
1238
1239    def all_library_calls(self) -> List["LibraryCall"]:
1240        """recursive version of library calls"""
1241        if self._all_library_calls is None:
1242            self._all_library_calls = self._explore_functions(lambda x: x.library_calls)
1243        return self._all_library_calls
1244
1245    def all_solidity_calls(self) -> List["SolidityCall"]:
1246        """recursive version of solidity calls"""
1247        if self._all_solidity_calls is None:
1248            self._all_solidity_calls = self._explore_functions(lambda x: x.solidity_calls)
1249        return self._all_solidity_calls
1250
1251    @staticmethod
1252    def _explore_func_cond_read(func: "Function", include_loop: bool) -> List["StateVariable"]:
1253        ret = [n.state_variables_read for n in func.nodes if n.is_conditional(include_loop)]
1254        return [item for sublist in ret for item in sublist]
1255
1256    def all_conditional_state_variables_read(self, include_loop=True) -> List["StateVariable"]:
1257        """
1258        Return the state variable used in a condition
1259
1260        Over approximate and also return index access
1261        It won't work if the variable is assigned to a temp variable
1262        """
1263        if include_loop:
1264            if self._all_conditional_state_variables_read_with_loop is None:
1265                self._all_conditional_state_variables_read_with_loop = self._explore_functions(
1266                    lambda x: self._explore_func_cond_read(x, include_loop)
1267                )
1268            return self._all_conditional_state_variables_read_with_loop
1269        if self._all_conditional_state_variables_read is None:
1270            self._all_conditional_state_variables_read = self._explore_functions(
1271                lambda x: self._explore_func_cond_read(x, include_loop)
1272            )
1273        return self._all_conditional_state_variables_read
1274
1275    @staticmethod
1276    def _solidity_variable_in_binary(node: "Node") -> List[SolidityVariable]:
1277        from slither.slithir.operations.binary import Binary
1278
1279        ret = []
1280        for ir in node.irs:
1281            if isinstance(ir, Binary):
1282                ret += ir.read
1283        return [var for var in ret if isinstance(var, SolidityVariable)]
1284
1285    @staticmethod
1286    def _explore_func_conditional(
1287        func: "Function",
1288        f: Callable[["Node"], List[SolidityVariable]],
1289        include_loop: bool,
1290    ) -> List[Any]:
1291        ret = [f(n) for n in func.nodes if n.is_conditional(include_loop)]
1292        return [item for sublist in ret for item in sublist]
1293
1294    def all_conditional_solidity_variables_read(
1295        self, include_loop: bool = True
1296    ) -> List[SolidityVariable]:
1297        """
1298        Return the Soldiity variables directly used in a condtion
1299
1300        Use of the IR to filter index access
1301        Assumption: the solidity vars are used directly in the conditional node
1302        It won't work if the variable is assigned to a temp variable
1303        """
1304        if include_loop:
1305            if self._all_conditional_solidity_variables_read_with_loop is None:
1306                self._all_conditional_solidity_variables_read_with_loop = self._explore_functions(
1307                    lambda x: self._explore_func_conditional(
1308                        x, self._solidity_variable_in_binary, include_loop
1309                    )
1310                )
1311            return self._all_conditional_solidity_variables_read_with_loop
1312
1313        if self._all_conditional_solidity_variables_read is None:
1314            self._all_conditional_solidity_variables_read = self._explore_functions(
1315                lambda x: self._explore_func_conditional(
1316                    x, self._solidity_variable_in_binary, include_loop
1317                )
1318            )
1319        return self._all_conditional_solidity_variables_read
1320
1321    @staticmethod
1322    def _solidity_variable_in_internal_calls(node: "Node") -> List[SolidityVariable]:
1323        from slither.slithir.operations.internal_call import InternalCall
1324
1325        ret = []
1326        for ir in node.irs:
1327            if isinstance(ir, InternalCall):
1328                ret += ir.read
1329        return [var for var in ret if isinstance(var, SolidityVariable)]
1330
1331    @staticmethod
1332    def _explore_func_nodes(
1333        func: "Function", f: Callable[["Node"], List[SolidityVariable]]
1334    ) -> List[Union[Any, SolidityVariableComposed]]:
1335        ret = [f(n) for n in func.nodes]
1336        return [item for sublist in ret for item in sublist]
1337
1338    def all_solidity_variables_used_as_args(self) -> List[SolidityVariable]:
1339        """
1340        Return the Soldiity variables directly used in a call
1341
1342        Use of the IR to filter index access
1343        Used to catch check(msg.sender)
1344        """
1345        if self._all_solidity_variables_used_as_args is None:
1346            self._all_solidity_variables_used_as_args = self._explore_functions(
1347                lambda x: self._explore_func_nodes(x, self._solidity_variable_in_internal_calls)
1348            )
1349        return self._all_solidity_variables_used_as_args
1350
1351    # endregion
1352    ###################################################################################
1353    ###################################################################################
1354    # region Visitor
1355    ###################################################################################
1356    ###################################################################################
1357
1358    def apply_visitor(self, Visitor: Callable) -> List:
1359        """
1360            Apply a visitor to all the function expressions
1361        Args:
1362            Visitor: slither.visitors
1363        Returns
1364            list(): results of the visit
1365        """
1366        expressions = self.expressions
1367        v = [Visitor(e).result() for e in expressions]
1368        return [item for sublist in v for item in sublist]
1369
1370    # endregion
1371    ###################################################################################
1372    ###################################################################################
1373    # region Getters from/to object
1374    ###################################################################################
1375    ###################################################################################
1376
1377    def get_local_variable_from_name(self, variable_name: str) -> Optional[LocalVariable]:
1378        """
1379            Return a local variable from a name
1380
1381        Args:
1382            variable_name (str): name of the variable
1383        Returns:
1384            LocalVariable
1385        """
1386        return next((v for v in self.variables if v.name == variable_name), None)
1387
1388    # endregion
1389    ###################################################################################
1390    ###################################################################################
1391    # region Export
1392    ###################################################################################
1393    ###################################################################################
1394
1395    def cfg_to_dot(self, filename: str):
1396        """
1397            Export the function to a dot file
1398        Args:
1399            filename (str)
1400        """
1401        with open(filename, "w", encoding="utf8") as f:
1402            f.write("digraph{\n")
1403            for node in self.nodes:
1404                f.write(f'{node.node_id}[label="{str(node)}"];\n')
1405                for son in node.sons:
1406                    f.write(f"{node.node_id}->{son.node_id};\n")
1407
1408            f.write("}\n")
1409
1410    def dominator_tree_to_dot(self, filename: str):
1411        """
1412            Export the dominator tree of the function to a dot file
1413        Args:
1414            filename (str)
1415        """
1416
1417        def description(node):
1418            desc = f"{node}\n"
1419            desc += f"id: {node.node_id}"
1420            if node.dominance_frontier:
1421                desc += f"\ndominance frontier: {[n.node_id for n in node.dominance_frontier]}"
1422            return desc
1423
1424        with open(filename, "w", encoding="utf8") as f:
1425            f.write("digraph{\n")
1426            for node in self.nodes:
1427                f.write(f'{node.node_id}[label="{description(node)}"];\n')
1428                if node.immediate_dominator:
1429                    f.write(f"{node.immediate_dominator.node_id}->{node.node_id};\n")
1430
1431            f.write("}\n")
1432
1433    def slithir_cfg_to_dot(self, filename: str):
1434        """
1435        Export the CFG to a DOT file. The nodes includes the Solidity expressions and the IRs
1436        :param filename:
1437        :return:
1438        """
1439        content = self.slithir_cfg_to_dot_str()
1440        with open(filename, "w", encoding="utf8") as f:
1441            f.write(content)
1442
1443    def slithir_cfg_to_dot_str(self, skip_expressions: bool = False) -> str:
1444        """
1445        Export the CFG to a DOT format. The nodes includes the Solidity expressions and the IRs
1446        :return: the DOT content
1447        :rtype: str
1448        """
1449        from slither.core.cfg.node import NodeType
1450
1451        content = ""
1452        content += "digraph{\n"
1453        for node in self.nodes:
1454            label = f"Node Type: {node.type.value} {node.node_id}\n"
1455            if node.expression and not skip_expressions:
1456                label += f"\nEXPRESSION:\n{node.expression}\n"
1457            if node.irs and not skip_expressions:
1458                label += "\nIRs:\n" + "\n".join([str(ir) for ir in node.irs])
1459            content += f'{node.node_id}[label="{label}"];\n'
1460            if node.type in [NodeType.IF, NodeType.IFLOOP]:
1461                true_node = node.son_true
1462                if true_node:
1463                    content += f'{node.node_id}->{true_node.node_id}[label="True"];\n'
1464                false_node = node.son_false
1465                if false_node:
1466                    content += f'{node.node_id}->{false_node.node_id}[label="False"];\n'
1467            else:
1468                for son in node.sons:
1469                    content += f"{node.node_id}->{son.node_id};\n"
1470
1471        content += "}\n"
1472        return content
1473
1474    # endregion
1475    ###################################################################################
1476    ###################################################################################
1477    # region Summary information
1478    ###################################################################################
1479    ###################################################################################
1480
1481    def is_reading(self, variable: "Variable") -> bool:
1482        """
1483            Check if the function reads the variable
1484        Args:
1485            variable (Variable):
1486        Returns:
1487            bool: True if the variable is read
1488        """
1489        return variable in self.variables_read
1490
1491    def is_reading_in_conditional_node(self, variable: "Variable") -> bool:
1492        """
1493            Check if the function reads the variable in a IF node
1494        Args:
1495            variable (Variable):
1496        Returns:
1497            bool: True if the variable is read
1498        """
1499        variables_reads = [n.variables_read for n in self.nodes if n.contains_if()]
1500        variables_read = [item for sublist in variables_reads for item in sublist]
1501        return variable in variables_read
1502
1503    def is_reading_in_require_or_assert(self, variable: "Variable") -> bool:
1504        """
1505            Check if the function reads the variable in an require or assert
1506        Args:
1507            variable (Variable):
1508        Returns:
1509            bool: True if the variable is read
1510        """
1511        variables_reads = [n.variables_read for n in self.nodes if n.contains_require_or_assert()]
1512        variables_read = [item for sublist in variables_reads for item in sublist]
1513        return variable in variables_read
1514
1515    def is_writing(self, variable: "Variable") -> bool:
1516        """
1517            Check if the function writes the variable
1518        Args:
1519            variable (Variable):
1520        Returns:
1521            bool: True if the variable is written
1522        """
1523        return variable in self.variables_written
1524
1525    @abstractmethod
1526    def get_summary(
1527        self,
1528    ) -> Tuple[str, str, str, List[str], List[str], List[str], List[str], List[str]]:
1529        pass
1530
1531    def is_protected(self) -> bool:
1532        """
1533            Determine if the function is protected using a check on msg.sender
1534
1535            Consider onlyOwner as a safe modifier.
1536            If the owner functionality is incorrectly implemented, this will lead to incorrectly
1537            classify the function as protected
1538
1539            Otherwise only detects if msg.sender is directly used in a condition
1540            For example, it wont work for:
1541                address a = msg.sender
1542                require(a == owner)
1543        Returns
1544            (bool)
1545        """
1546
1547        if self._is_protected is None:
1548            if self.is_constructor:
1549                self._is_protected = True
1550                return True
1551            if "onlyOwner" in [m.name for m in self.modifiers]:
1552                self._is_protected = True
1553                return True
1554            conditional_vars = self.all_conditional_solidity_variables_read(include_loop=False)
1555            args_vars = self.all_solidity_variables_used_as_args()
1556            self._is_protected = (
1557                SolidityVariableComposed("msg.sender") in conditional_vars + args_vars
1558            )
1559        return self._is_protected
1560
1561    @property
1562    def is_reentrant(self) -> bool:
1563        """
1564        Determine if the function can be re-entered
1565        """
1566        reentrancy_modifier = "nonReentrant"
1567
1568        if self.function_language == FunctionLanguage.Vyper:
1569            reentrancy_modifier = "nonreentrant(lock)"
1570
1571        # TODO: compare with hash of known nonReentrant modifier instead of the name
1572        if reentrancy_modifier in [m.name for m in self.modifiers]:
1573            return False
1574
1575        if self.visibility in ["public", "external"]:
1576            return True
1577
1578        # If it's an internal function, check if all its entry points have the nonReentrant modifier
1579        all_entry_points = [
1580            f for f in self.all_reachable_from_functions if f.visibility in ["public", "external"]
1581        ]
1582        if not all_entry_points:
1583            return True
1584        return not all(
1585            (reentrancy_modifier in [m.name for m in f.modifiers] for f in all_entry_points)
1586        )
1587
1588    # endregion
1589    ###################################################################################
1590    ###################################################################################
1591    # region Analyses
1592    ###################################################################################
1593    ###################################################################################
1594
1595    def _analyze_read_write(self) -> None:
1596        """Compute variables read/written/..."""
1597        write_var = [x.variables_written_as_expression for x in self.nodes]
1598        write_var = [x for x in write_var if x]
1599        write_var = [item for sublist in write_var for item in sublist]
1600        write_var = list(set(write_var))
1601        # Remove duplicate if they share the same string representation
1602        write_var = [
1603            next(obj)
1604            for i, obj in groupby(sorted(write_var, key=lambda x: str(x)), lambda x: str(x))
1605        ]
1606        self._expression_vars_written = write_var
1607
1608        write_var = [x.variables_written for x in self.nodes]
1609        write_var = [x for x in write_var if x]
1610        write_var = [item for sublist in write_var for item in sublist]
1611        write_var = list(set(write_var))
1612        # Remove duplicate if they share the same string representation
1613        write_var = [
1614            next(obj)
1615            for i, obj in groupby(sorted(write_var, key=lambda x: str(x)), lambda x: str(x))
1616        ]
1617        self._vars_written = write_var
1618
1619        read_var = [x.variables_read_as_expression for x in self.nodes]
1620        read_var = [x for x in read_var if x]
1621        read_var = [item for sublist in read_var for item in sublist]
1622        # Remove duplicate if they share the same string representation
1623        read_var = [
1624            next(obj)
1625            for i, obj in groupby(sorted(read_var, key=lambda x: str(x)), lambda x: str(x))
1626        ]
1627        self._expression_vars_read = read_var
1628
1629        read_var = [x.variables_read for x in self.nodes]
1630        read_var = [x for x in read_var if x]
1631        read_var = [item for sublist in read_var for item in sublist]
1632        # Remove duplicate if they share the same string representation
1633        read_var = [
1634            next(obj)
1635            for i, obj in groupby(sorted(read_var, key=lambda x: str(x)), lambda x: str(x))
1636        ]
1637        self._vars_read = read_var
1638
1639        self._state_vars_written = [
1640            x for x in self.variables_written if isinstance(x, StateVariable)
1641        ]
1642        self._state_vars_read = [x for x in self.variables_read if isinstance(x, StateVariable)]
1643        self._solidity_vars_read = [
1644            x for x in self.variables_read if isinstance(x, SolidityVariable)
1645        ]
1646
1647        self._vars_read_or_written = self._vars_written + self._vars_read
1648
1649        slithir_variables = [x.slithir_variables for x in self.nodes]
1650        slithir_variables = [x for x in slithir_variables if x]
1651        self._slithir_variables = [item for sublist in slithir_variables for item in sublist]
1652
1653    def _analyze_calls(self) -> None:
1654        calls = [x.calls_as_expression for x in self.nodes]
1655        calls = [x for x in calls if x]
1656        calls = [item for sublist in calls for item in sublist]
1657        self._expression_calls = list(set(calls))
1658
1659        internal_calls = [x.internal_calls for x in self.nodes]
1660        internal_calls = [x for x in internal_calls if x]
1661        internal_calls = [item for sublist in internal_calls for item in sublist]
1662        self._internal_calls = list(set(internal_calls))
1663
1664        self._solidity_calls = [
1665            ir for ir in internal_calls if isinstance(ir.function, SolidityFunction)
1666        ]
1667
1668        low_level_calls = [x.low_level_calls for x in self.nodes]
1669        low_level_calls = [x for x in low_level_calls if x]
1670        low_level_calls = [item for sublist in low_level_calls for item in sublist]
1671        self._low_level_calls = list(set(low_level_calls))
1672
1673        high_level_calls = [x.high_level_calls for x in self.nodes]
1674        high_level_calls = [x for x in high_level_calls if x]
1675        high_level_calls = [item for sublist in high_level_calls for item in sublist]
1676        self._high_level_calls = list(set(high_level_calls))
1677
1678        library_calls = [x.library_calls for x in self.nodes]
1679        library_calls = [x for x in library_calls if x]
1680        library_calls = [item for sublist in library_calls for item in sublist]
1681        self._library_calls = list(set(library_calls))
1682
1683        external_calls_as_expressions = [x.external_calls_as_expressions for x in self.nodes]
1684        external_calls_as_expressions = [x for x in external_calls_as_expressions if x]
1685        external_calls_as_expressions = [
1686            item for sublist in external_calls_as_expressions for item in sublist
1687        ]
1688        self._external_calls_as_expressions = list(set(external_calls_as_expressions))
1689
1690    # endregion
1691    ###################################################################################
1692    ###################################################################################
1693    # region Nodes
1694    ###################################################################################
1695    ###################################################################################
1696
1697    def new_node(
1698        self, node_type: "NodeType", src: Union[str, Dict], scope: Union[Scope, "Function"]
1699    ) -> "Node":
1700        from slither.core.cfg.node import Node
1701
1702        node = Node(node_type, self._counter_nodes, scope, self.file_scope)
1703        node.set_offset(src, self.compilation_unit)
1704        self._counter_nodes += 1
1705        node.set_function(self)
1706        self._nodes.append(node)
1707
1708        return node
1709
1710    # endregion
1711    ###################################################################################
1712    ###################################################################################
1713    # region SlithIr and SSA
1714    ###################################################################################
1715    ###################################################################################
1716
1717    def _get_last_ssa_variable_instances(
1718        self, target_state: bool, target_local: bool
1719    ) -> Dict[str, Set["SlithIRVariable"]]:
1720        # pylint: disable=too-many-locals,too-many-branches
1721        from slither.slithir.variables import ReferenceVariable
1722        from slither.slithir.operations import OperationWithLValue
1723        from slither.core.cfg.node import NodeType
1724
1725        if not self.is_implemented:
1726            return {}
1727
1728        if self._entry_point is None:
1729            return {}
1730        # node, values
1731        to_explore: List[Tuple["Node", Dict]] = [(self._entry_point, {})]
1732        # node -> values
1733        explored: Dict = {}
1734        # name -> instances
1735        ret: Dict = {}
1736
1737        while to_explore:
1738            node, values = to_explore[0]
1739            to_explore = to_explore[1::]
1740
1741            if node.type != NodeType.ENTRYPOINT:
1742                for ir_ssa in node.irs_ssa:
1743                    if isinstance(ir_ssa, OperationWithLValue):
1744                        lvalue = ir_ssa.lvalue
1745                        if isinstance(lvalue, ReferenceVariable):
1746                            lvalue = lvalue.points_to_origin
1747                        if isinstance(lvalue, StateVariable) and target_state:
1748                            values[lvalue.canonical_name] = {lvalue}
1749                        if isinstance(lvalue, LocalVariable) and target_local:
1750                            values[lvalue.canonical_name] = {lvalue}
1751
1752            # Check for fixpoint
1753            if node in explored:
1754                if values == explored[node]:
1755                    continue
1756                for k, instances in values.items():
1757                    if k not in explored[node]:
1758                        explored[node][k] = set()
1759                    explored[node][k] |= instances
1760                values = explored[node]
1761            else:
1762                explored[node] = values
1763
1764            # Return condition
1765            if node.will_return:
1766                for name, instances in values.items():
1767                    if name not in ret:
1768                        ret[name] = set()
1769                    ret[name] |= instances
1770
1771            for son in node.sons:
1772                to_explore.append((son, dict(values)))
1773
1774        return ret
1775
1776    def get_last_ssa_state_variables_instances(
1777        self,
1778    ) -> Dict[str, Set["SlithIRVariable"]]:
1779        return self._get_last_ssa_variable_instances(target_state=True, target_local=False)
1780
1781    def get_last_ssa_local_variables_instances(
1782        self,
1783    ) -> Dict[str, Set["SlithIRVariable"]]:
1784        return self._get_last_ssa_variable_instances(target_state=False, target_local=True)
1785
1786    @staticmethod
1787    def _unchange_phi(ir: "Operation") -> bool:
1788        from slither.slithir.operations import Phi, PhiCallback
1789
1790        if not isinstance(ir, (Phi, PhiCallback)) or len(ir.rvalues) > 1:
1791            return False
1792        if not ir.rvalues:
1793            return True
1794        return ir.rvalues[0] == ir.lvalue
1795
1796    def fix_phi(
1797        self,
1798        last_state_variables_instances: Dict[str, List["StateVariable"]],
1799        initial_state_variables_instances: Dict[str, "StateVariable"],
1800    ) -> None:
1801        from slither.slithir.operations import InternalCall, PhiCallback
1802        from slither.slithir.variables import Constant, StateIRVariable
1803
1804        for node in self.nodes:
1805            for ir in node.irs_ssa:
1806                if node == self.entry_point:
1807                    if isinstance(ir.lvalue, StateIRVariable):
1808                        additional = [initial_state_variables_instances[ir.lvalue.canonical_name]]
1809                        additional += last_state_variables_instances[ir.lvalue.canonical_name]
1810                        ir.rvalues = list(set(additional + ir.rvalues))
1811                    # function parameter
1812                    else:
1813                        # find index of the parameter
1814                        idx = self.parameters.index(ir.lvalue.non_ssa_version)
1815                        # find non ssa version of that index
1816                        additional = [n.ir.arguments[idx] for n in self.reachable_from_nodes]
1817                        additional = unroll(additional)
1818                        additional = [a for a in additional if not isinstance(a, Constant)]
1819                        ir.rvalues = list(set(additional + ir.rvalues))
1820                if isinstance(ir, PhiCallback):
1821                    callee_ir = ir.callee_ir
1822                    if isinstance(callee_ir, InternalCall):
1823                        last_ssa = callee_ir.function.get_last_ssa_state_variables_instances()
1824                        if ir.lvalue.canonical_name in last_ssa:
1825                            ir.rvalues = list(last_ssa[ir.lvalue.canonical_name])
1826                        else:
1827                            ir.rvalues = [ir.lvalue]
1828                    else:
1829                        additional = last_state_variables_instances[ir.lvalue.canonical_name]
1830                        ir.rvalues = list(set(additional + ir.rvalues))
1831
1832            node.irs_ssa = [ir for ir in node.irs_ssa if not self._unchange_phi(ir)]
1833
1834    def generate_slithir_and_analyze(self) -> None:
1835
1836        for node in self.nodes:
1837            node.slithir_generation()
1838
1839        self._analyze_read_write()
1840        self._analyze_calls()
1841
1842    @abstractmethod
1843    def generate_slithir_ssa(self, all_ssa_state_variables_instances):
1844        pass
1845
1846    def update_read_write_using_ssa(self) -> None:
1847        for node in self.nodes:
1848            node.update_read_write_using_ssa()
1849        self._analyze_read_write()
1850
1851    ###################################################################################
1852    ###################################################################################
1853    # region Built in definitions
1854    ###################################################################################
1855    ###################################################################################
1856
1857    def __str__(self) -> str:
1858        return self.name
1859
1860    # endregion