Merge pull request #305 from crytic/dev-late-subdenomination-conversion

Late subdenomination conversion

scripts/tests_generate_expected_json_5.sh

@@ -20,7 +20,7 @@ generate_expected_json(){
     sed "s|$CURRENT_PATH|$TRAVIS_PATH|g" "$output_filename_txt" -i
 }
 
-generate_expected_json tests/void-cst.sol "void-cst"
+#generate_expected_json tests/void-cst.sol "void-cst"
 #generate_expected_json tests/solc_version_incorrect_05.ast.json "solc-version"
 #generate_expected_json tests/uninitialized-0.5.1.sol "uninitialized-state"
 #generate_expected_json tests/backdoor.sol "backdoor"

slither/core/expressions/literal.py

@@ -1,11 +1,13 @@
 from slither.core.expressions.expression import Expression
+from slither.utils.arithmetic import convert_subdenomination
 
 class Literal(Expression):
 
-    def __init__(self, value, type):
+    def __init__(self, value, type, subdenomination=None):
         super(Literal, self).__init__()
         self._value = value
         self._type = type
+        self._subdenomination = subdenomination
 
     @property
     def value(self):
@@ -15,6 +17,12 @@ def value(self):
     def type(self):
         return self._type
 
+    @property
+    def subdenomination(self):
+        return self._subdenomination
+
     def __str__(self):
+        if self.subdenomination:
+            return str(convert_subdenomination(self._value, self.subdenomination))
         # be sure to handle any character
         return str(self._value)

slither/detectors/statements/too_many_digits.py

@@ -48,7 +48,6 @@ def _detect_too_many_digits(f):
                     if isinstance(read, Constant):
                         # read.value can return an int or a str. Convert it to str
                         value_as_str = read.original_value
-                        line_of_code = str(node.expression)
                         if '00000' in value_as_str:
                             # Info to be printed
                             ret.append(node)

slither/slithir/variables/constant.py

@@ -1,14 +1,18 @@
 from .variable import SlithIRVariable
 from slither.core.solidity_types.elementary_type import ElementaryType, Int, Uint
-
+from slither.utils.arithmetic import convert_subdenomination
 
 class Constant(SlithIRVariable):
 
-    def __init__(self, val, type=None):
+    def __init__(self, val, type=None, subdenomination=None):
         super(Constant, self).__init__()
         assert isinstance(val, str)
 
         self._original_value = val
+        self._subdenomination = subdenomination
+
+        if subdenomination:
+            val = str(convert_subdenomination(val, subdenomination))
 
         if type:
             assert isinstance(type, ElementaryType)

slither/solc_parsing/expressions/expression_parsing.py

@@ -220,45 +220,7 @@ def filter_name(value):
     return value
 
 # endregion
-###################################################################################
-###################################################################################
-# region Conversion
-###################################################################################
-###################################################################################
-
-def convert_subdenomination(value, sub):
-    if sub is None:
-        return value
-    # to allow 0.1 ether conversion
-    if value[0:2] == "0x":
-        value = float(int(value, 16))
-    else:
-        value = float(value)
-    if sub == 'wei':
-        return int(value)
-    if sub == 'szabo':
-        return int(value * int(1e12))
-    if sub == 'finney':
-        return int(value * int(1e15))
-    if sub == 'ether':
-        return int(value * int(1e18))
-    if sub == 'seconds':
-        return int(value)
-    if sub == 'minutes':
-        return int(value * 60)
-    if sub == 'hours':
-        return int(value * 60 * 60)
-    if sub == 'days':
-        return int(value * 60 * 60 * 24)
-    if sub == 'weeks':
-        return int(value * 60 * 60 * 24 * 7)
-    if sub == 'years':
-        return int(value * 60 * 60 * 24 * 7 * 365)
-
-    logger.error('Subdemoniation not found {}'.format(sub))
-    return int(value)
 
-# endregion
 ###################################################################################
 ###################################################################################
 # region Parsing
@@ -489,14 +451,19 @@ def parse_expression(expression, caller_context):
         assignement = AssignmentOperation(left_expression, right_expression, operation_type, operation_return_type)
         return assignement
 
+
+
     elif name == 'Literal':
+
+        subdenomination = None
+
         assert 'children' not in expression
 
         if is_compact_ast:
             value = expression['value']
             if value:
                 if 'subdenomination' in expression and expression['subdenomination']:
-                    value = str(convert_subdenomination(value, expression['subdenomination']))
+                    subdenomination = expression['subdenomination']
             elif not value and value != "":
                 value = '0x'+expression['hexValue']
             type = expression['typeDescriptions']['typeString']
@@ -509,7 +476,7 @@ def parse_expression(expression, caller_context):
             value = expression['attributes']['value']
             if value:
                 if 'subdenomination' in expression['attributes'] and expression['attributes']['subdenomination']:
-                    value = str(convert_subdenomination(value, expression['attributes']['subdenomination']))
+                    subdenomination = expression['attributes']['subdenomination']
             elif value is None:
                 # for literal declared as hex
                 # see https://solidity.readthedocs.io/en/v0.4.25/types.html?highlight=hex#hexadecimal-literals
@@ -530,7 +497,7 @@ def parse_expression(expression, caller_context):
             type = ElementaryType('address')
         else:
             type = ElementaryType('string')
-        literal = Literal(value, type)
+        literal = Literal(value, type, subdenomination)
         return literal
 
     elif name == 'Identifier':

slither/solc_parsing/slitherSolc.py

@@ -224,11 +224,11 @@ def _analyze_contracts(self):
                     else:
                         father_constructors.append(self._contracts_by_id[i])
 
-            except KeyError:
-                txt = 'A contract was not found, it is likely that your codebase contains muliple contracts with the same name'
-                txt += 'Truffle does not handle this case during compilation'
-                txt += 'Please read https://github.com/trailofbits/slither/wiki#keyerror-or-nonetype-error'
-                txt += 'And update your code to remove the duplicate'
+            except KeyError as e:
+                txt = f'A contract was not found (id {e}), it is likely that your codebase contains muliple contracts with the same name. '
+                txt += 'Truffle does not handle this case during compilation. '
+                txt += 'Please read https://github.com/trailofbits/slither/wiki#keyerror-or-nonetype-error, '
+                txt += 'and update your code to remove the duplicate'
                 raise ParsingContractNotFound(txt)
             contract.setInheritance(ancestors, fathers, father_constructors)
 

slither/utils/arithmetic.py

@@ -0,0 +1,32 @@
+from slither.exceptions import SlitherException
+
+
+def convert_subdenomination(value, sub):
+
+    # to allow 0.1 ether conversion
+    if value[0:2] == "0x":
+        value = float(int(value, 16))
+    else:
+        value = float(value)
+    if sub == 'wei':
+        return int(value)
+    if sub == 'szabo':
+        return int(value * int(1e12))
+    if sub == 'finney':
+        return int(value * int(1e15))
+    if sub == 'ether':
+        return int(value * int(1e18))
+    if sub == 'seconds':
+        return int(value)
+    if sub == 'minutes':
+        return int(value * 60)
+    if sub == 'hours':
+        return int(value * 60 * 60)
+    if sub == 'days':
+        return int(value * 60 * 60 * 24)
+    if sub == 'weeks':
+        return int(value * 60 * 60 * 24 * 7)
+    if sub == 'years':
+        return int(value * 60 * 60 * 24 * 7 * 365)
+
+    raise SlitherException(f'Subdemonination conversion impossible {value} {sub}')

slither/visitors/slithir/expression_to_slithir.py

@@ -171,7 +171,7 @@ def _post_index_access(self, expression):
         set_val(expression, val)
 
     def _post_literal(self, expression):
-        cst = Constant(expression.value, expression.type)
+        cst = Constant(expression.value, expression.type, expression.subdenomination)
         set_val(expression, cst)
 
     def _post_member_access(self, expression):