Rename original_contract -> contract_declarer

examples/scripts/slithIR.py

@@ -15,7 +15,7 @@
     for function in contract.functions:
 
         # Dont explore inherited functions
-        if function.original_contract == contract:
+        if function.contract_declarer == contract:
 
             print('Function: {}'.format(function.name))
 

slither/core/children/child_contract.py

@@ -4,7 +4,6 @@ class ChildContract:
     def __init__(self):
         super(ChildContract, self).__init__()
         self._contract = None
-        self._original_contract = None
 
     def set_contract(self, contract):
         self._contract = contract

slither/core/children/child_inheritance.py

@@ -3,11 +3,11 @@ class ChildInheritance:
 
     def __init__(self):
         super(ChildInheritance, self).__init__()
-        self._original_contract = None
+        self._contract_declarer = None
 
-    def set_original_contract(self, original_contract):
-        self._original_contract = original_contract
+    def set_contract_declarer(self, contract):
+        self._contract_declarer = contract
 
     @property
-    def original_contract(self):
-        return self._original_contract
+    def contract_declarer(self):
+        return self._contract_declarer

slither/core/declarations/contract.py

@@ -184,7 +184,7 @@ def constructor(self):
 
     @property
     def constructor_not_inherited(self):
-        return next((func for func in self.functions if func.is_constructor and func.original_contract == self), None)
+        return next((func for func in self.functions if func.is_constructor and func.contract_declarer == self), None)
 
     @property
     def constructors(self):
@@ -228,14 +228,14 @@ def functions_inherited(self):
         '''
             list(Function): List of the inherited functions
         '''
-        return [f for f in self.functions if f.original_contract != self]
+        return [f for f in self.functions if f.contract_declarer != self]
 
     @property
     def functions_not_inherited(self):
         '''
             list(Function): List of the functions defined within the contract (not inherited)
         '''
-        return [f for f in self.functions if f.original_contract == self]
+        return [f for f in self.functions if f.contract_declarer == self]
 
     @property
     def functions_entry_points(self):
@@ -259,14 +259,14 @@ def modifiers_inherited(self):
         '''
             list(Modifier): List of the inherited modifiers
         '''
-        return [m for m in self.modifiers if m.original_contract != self]
+        return [m for m in self.modifiers if m.contract_declarer != self]
 
     @property
     def modifiers_not_inherited(self):
         '''
             list(Modifier): List of the modifiers defined within the contract (not inherited)
         '''
-        return [m for m in self.modifiers if m.original_contract == self]
+        return [m for m in self.modifiers if m.contract_declarer == self]
 
     @property
     def functions_and_modifiers(self):
@@ -518,7 +518,8 @@ def get_functions_overridden_by(self, function):
     @property
     def all_functions_called(self):
         '''
-            list(Function): List of functions reachable from the contract (include super)
+            list(Function): List of functions reachable from the contract
+            Includes super, and private/internal functions not shadowed
         '''
         all_calls = [f for f in self.functions + self.modifiers if not f.is_shadowed]
         all_calls = [f.all_internal_calls() for f in all_calls] + [all_calls]

slither/core/declarations/function.py

@@ -123,14 +123,14 @@ def canonical_name(self):
             Return the function signature without the return values
         """
         name, parameters, _ = self.signature
-        return self.original_contract.name + '.' + name + '(' + ','.join(parameters) + ')'
+        return self.contract_declarer.name + '.' + name + '(' + ','.join(parameters) + ')'
 
     @property
     def is_constructor(self):
         """
             bool: True if the function is the constructor
         """
-        return self._is_constructor or self._name == self.original_contract.name
+        return self._is_constructor or self._name == self.contract_declarer.name
 
     @property
     def contains_assembly(self):
@@ -950,7 +950,7 @@ def get_summary(self):
             (str, str, str, list(str), list(str), listr(str), list(str), list(str);
             contract_name, name, visibility, modifiers, vars read, vars written, internal_calls, external_calls_as_expressions
         """
-        return (self.original_contract.name, self.full_name, self.visibility,
+        return (self.contract_declarer.name, self.full_name, self.visibility,
                 [str(x) for x in self.modifiers],
                 [str(x) for x in self.state_variables_read + self.solidity_variables_read],
                 [str(x) for x in self.state_variables_written],

slither/detectors/abstract_detector.py

@@ -169,7 +169,7 @@ def add_contract_to_json(contract, d):
     @staticmethod
     def add_function_to_json(function, d):
         contract = {'elements':[]}
-        AbstractDetector.add_contract_to_json(function.original_contract, contract)
+        AbstractDetector.add_contract_to_json(function.contract_declarer, contract)
         d['elements'].append({'type': 'function',
                               'name': function.name,
                               'source_mapping': function.source_mapping,

slither/detectors/attributes/const_functions.py

@@ -51,7 +51,7 @@ def _detect(self):
         results = []
         for c in self.contracts:
             for f in c.functions:
-                if f.original_contract != c:
+                if f.contract_declarer != c:
                     continue
                 if f.view or f.pure:
                     if f.contains_assembly:

slither/detectors/erc20/incorrect_interface.py

@@ -52,7 +52,7 @@ def detect_incorrect_erc20_interface(contract):
         Returns:
             list(str) : list of incorrect function signatures
         """
-        functions = [f for f in contract.functions if f.original_contract == contract and \
+        functions = [f for f in contract.functions if f.contract_declarer == contract and \
                      IncorrectERC20InterfaceDetection.incorrect_erc20_interface(f.signature)]
         return functions
 

slither/detectors/functions/arbitrary_send.py

@@ -94,7 +94,7 @@ def detect_arbitrary_send(self, contract):
             list((Function), (list (Node)))
         """
         ret = []
-        for f in [f for f in contract.functions if f.original_contract == contract]:
+        for f in [f for f in contract.functions if f.contract_declarer == contract]:
             nodes = self.arbitrary_send(f)
             if nodes:
                 ret.append((f, nodes))

slither/detectors/functions/suicidal.py

@@ -59,7 +59,7 @@ def detect_suicidal_func(func):
 
     def detect_suicidal(self, contract):
         ret = []
-        for f in [f for f in contract.functions if f.original_contract == contract]:
+        for f in [f for f in contract.functions if f.contract_declarer == contract]:
             if self.detect_suicidal_func(f):
                 ret.append(f)
         return ret

slither/detectors/naming_convention/naming_convention.py

@@ -103,7 +103,7 @@ def _detect(self):
                     results.append(json)
 
             for func in contract.functions:
-                if func.original_contract != contract:
+                if func.contract_declarer != contract:
                     continue
 
                 if not self.is_mixed_case(func.name):
@@ -212,7 +212,7 @@ def _detect(self):
 
 
             for modifier in contract.modifiers:
-                if modifier.original_contract != contract:
+                if modifier.contract_declarer != contract:
                     continue
 
                 if not self.is_mixed_case(modifier.name):

slither/detectors/operations/block_timestamp.py

@@ -54,7 +54,7 @@ def detect_dangerous_timestamp(self, contract):
             list((Function), (list (Node)))
         """
         ret = []
-        for f in [f for f in contract.functions if f.original_contract == contract]:
+        for f in [f for f in contract.functions if f.contract_declarer == contract]:
             nodes = self.timestamp(f)
             if nodes:
                 ret.append((f, nodes))

slither/detectors/operations/low_level_calls.py

@@ -33,7 +33,7 @@ def _contains_low_level_calls(node):
 
     def detect_low_level_calls(self, contract):
         ret = []
-        for f in [f for f in contract.functions if contract == f.original_contract]:
+        for f in [f for f in contract.functions if contract == f.contract_declarer]:
             nodes = f.nodes
             assembly_nodes = [n for n in nodes if
                               self._contains_low_level_calls(n)]

slither/detectors/operations/unused_return_values.py

@@ -64,7 +64,7 @@ def _detect(self):
         results = []
         for c in self.slither.contracts:
             for f in c.functions + c.modifiers:
-                if f.original_contract != c:
+                if f.contract_declarer != c:
                     continue
                 unused_return = self.detect_unused_return_values(f)
                 if unused_return:

slither/detectors/shadowing/builtin_symbols.py

@@ -91,12 +91,12 @@ def detect_builtin_shadowing_definitions(self, contract):
 
         # Loop through all functions, modifiers, variables (state and local) to detect any built-in symbol keywords.
         for function in contract.functions:
-            if function.original_contract == contract:
+            if function.contract_declarer == contract:
                 if self.is_builtin_symbol(function.name):
                     result.append((self.SHADOWING_FUNCTION, function, None))
                 result += self.detect_builtin_shadowing_locals(function)
         for modifier in contract.modifiers:
-            if modifier.original_contract == contract:
+            if modifier.contract_declarer == contract:
                 if self.is_builtin_symbol(modifier.name):
                     result.append((self.SHADOWING_MODIFIER, modifier, None))
                 result += self.detect_builtin_shadowing_locals(modifier)

slither/detectors/shadowing/local.py

@@ -59,7 +59,7 @@ def detect_shadowing_definitions(self, contract):
         # Loop through all functions + modifiers in this contract.
         for function in contract.functions + contract.modifiers:
             # We should only look for functions declared directly in this contract (not in a base contract).
-            if function.original_contract != contract:
+            if function.contract_declarer != contract:
                 continue
 
             # This function was declared in this contract, we check what its local variables might shadow.
@@ -68,11 +68,11 @@ def detect_shadowing_definitions(self, contract):
                 for scope_contract in [contract] + contract.inheritance:
                     # Check functions
                     for scope_function in scope_contract.functions:
-                        if variable.name == scope_function.name and scope_function.original_contract == scope_contract:
+                        if variable.name == scope_function.name and scope_function.contract_declarer == scope_contract:
                             overshadowed.append((self.OVERSHADOWED_FUNCTION, scope_contract.name, scope_function))
                     # Check modifiers
                     for scope_modifier in scope_contract.modifiers:
-                        if variable.name == scope_modifier.name and scope_modifier.original_contract == scope_contract:
+                        if variable.name == scope_modifier.name and scope_modifier.contract_declarer == scope_contract:
                             overshadowed.append((self.OVERSHADOWED_MODIFIER, scope_contract.name, scope_modifier))
                     # Check events
                     for scope_event in scope_contract.events:

slither/detectors/statements/assembly.py

@@ -35,7 +35,7 @@ def _contains_inline_assembly_use(node):
     def detect_assembly(self, contract):
         ret = []
         for f in contract.functions:
-            if f.original_contract != contract:
+            if f.contract_declarer != contract:
                 continue
             nodes = f.nodes
             assembly_nodes = [n for n in nodes if

slither/detectors/statements/calls_in_loop.py

@@ -72,7 +72,7 @@ def call_in_loop(node, in_loop, visited, ret):
     def detect_call_in_loop(contract):
         ret = []
         for f in contract.functions + contract.modifiers:
-            if f.original_contract == contract and f.is_implemented:
+            if f.contract_declarer == contract and f.is_implemented:
                 MultipleCallsInLoop.call_in_loop(f.entry_point,
                                                  False, [], ret)
 

slither/detectors/statements/controlled_delegatecall.py

@@ -42,7 +42,7 @@ def _detect(self):
 
         for contract in self.slither.contracts:
             for f in contract.functions:
-                if f.original_contract != contract:
+                if f.contract_declarer != contract:
                     continue
                 nodes = self.controlled_delegatecall(f)
                 if nodes:

slither/detectors/variables/uninitialized_local_variables.py

@@ -90,7 +90,7 @@ def _detect(self):
 
         for contract in self.slither.contracts:
             for function in contract.functions:
-                if function.is_implemented and function.original_contract == contract:
+                if function.is_implemented and function.contract_declarer == contract:
                     if function.contains_assembly:
                         continue
                     # dont consider storage variable, as they are detected by another detector

slither/printers/inheritance/inheritance_graph.py

@@ -116,14 +116,14 @@ def _summary(self, contract):
         # Functions
         visibilities = ['public', 'external']
         public_functions = [self._get_pattern_func(f, contract) for f in contract.functions if
-                            not f.is_constructor and f.original_contract == contract and f.visibility in visibilities]
+                            not f.is_constructor and f.contract_declarer == contract and f.visibility in visibilities]
         public_functions = ''.join(public_functions)
         private_functions = [self._get_pattern_func(f, contract) for f in contract.functions if
-                             not f.is_constructor and f.original_contract == contract and f.visibility not in visibilities]
+                             not f.is_constructor and f.contract_declarer == contract and f.visibility not in visibilities]
         private_functions = ''.join(private_functions)
 
         # Modifiers
-        modifiers = [self._get_pattern_func(m, contract) for m in contract.modifiers if m.original_contract == contract]
+        modifiers = [self._get_pattern_func(m, contract) for m in contract.modifiers if m.contract_declarer == contract]
         modifiers = ''.join(modifiers)
 
         # Public variables

slither/slithir/operations/internal_call.py

@@ -10,7 +10,7 @@ def __init__(self, function, nbr_arguments, result, type_call):
         if isinstance(function, Function):
             self._function = function
             self._function_name = function.name
-            self._contract_name = function.original_contract.name
+            self._contract_name = function.contract_declarer.name
         else:
             self._function = None
             self._function_name, self._contract_name = function

slither/solc_parsing/declarations/contract.py

@@ -234,7 +234,7 @@ def _parse_modifier(self, modifier):
 
         modif = ModifierSolc(modifier, self, self)
         modif.set_contract(self)
-        modif.set_original_contract(self)
+        modif.set_contract_declarer(self)
         modif.set_offset(modifier['src'], self.slither)
         self.slither.add_modifier(modif)
         self._modifiers_no_params.append(modif)
@@ -321,7 +321,7 @@ def _analyze_params_elements(self, elements_no_params, getter, getter_available,
 
         for father in self.inheritance:
             for element in getter(father):
-                elem = Cls(element._functionNotParsed, self, element.original_contract)
+                elem = Cls(element._functionNotParsed, self, element.contract_declarer)
                 elem.set_offset(element._functionNotParsed['src'], self.slither)
                 elem.analyze_params()
                 self.slither.add_function(elem)

slither/solc_parsing/declarations/function.py

@@ -34,10 +34,10 @@ class FunctionSolc(Function):
     """
     # elems = [(type, name)]
 
-    def __init__(self, function, contract, original_contract):
+    def __init__(self, function, contract, contract_declarer):
         super(FunctionSolc, self).__init__()
         self._contract = contract
-        self._original_contract = original_contract
+        self._contract_declarer = contract_declarer
 
         # Only present if compact AST
         self._referenced_declaration = None

slither/utils/inheritance_analysis.py

@@ -109,7 +109,7 @@ def detect_function_shadowing(contracts, direct_shadowing=True, indirect_shadowi
                     for y in range(x + 1, len(colliding_functions)):
                         # The same function definition can appear more than once in the inheritance chain,
                         # overshadowing items between, so it is important to remember to filter it out here.
-                        if colliding_functions[y][1].original_contract != colliding_functions[x][1].original_contract:
+                        if colliding_functions[y][1].contract_declarer != colliding_functions[x][1].contract_declarer:
                             results.add((contract, colliding_functions[y][0], colliding_functions[y][1],
                                          colliding_functions[x][0], colliding_functions[x][1]))
 

utils/possible_paths/__main__.py

@@ -47,7 +47,7 @@ def main():
     # Print out all target functions.
     print(f"Target functions:")
     for target in targets:
-        print(f"- {target.original_contract.name}.{target.full_name}")
+        print(f"- {target.contract_declarer.name}.{target.full_name}")
     print("\n")
 
     # Obtain all paths which reach the target functions.