Merge branch 'dev' into dev-types

.github/workflows/features.yml

@@ -45,7 +45,7 @@ jobs:
       - name: Test with pytest
         run: |
           pytest tests/test_features.py
-          pytest tests/test_constant_folding_unary.py
+          pytest tests/test_constant_folding.py
           pytest tests/slithir/test_ternary_expressions.py
           pytest tests/test_functions_ids.py
           pytest tests/test_function.py

Dockerfile

@@ -26,6 +26,14 @@ RUN export DEBIAN_FRONTEND=noninteractive \
   && apt-get install -y --no-install-recommends python3-pip \
   && rm -rf /var/lib/apt/lists/*
 
+# improve compatibility with amd64 solc in non-amd64 environments (e.g. Docker Desktop on M1 Mac)
+ENV QEMU_LD_PREFIX=/usr/x86_64-linux-gnu
+RUN if [ ! "$(uname -m)" = "x86_64" ]; then \
+  export DEBIAN_FRONTEND=noninteractive \
+  && apt-get update \
+  && apt-get install -y --no-install-recommends libc6-amd64-cross \
+  && rm -rf /var/lib/apt/lists/*; fi
+
 RUN useradd -m slither
 USER slither
 

slither/core/expressions/literal.py

@@ -1,7 +1,9 @@
 from typing import Optional, Union, TYPE_CHECKING
 
 from slither.core.expressions.expression import Expression
+from slither.core.solidity_types.elementary_type import Fixed, Int, Ufixed, Uint
 from slither.utils.arithmetic import convert_subdenomination
+from slither.utils.integer_conversion import convert_string_to_int
 
 if TYPE_CHECKING:
     from slither.core.solidity_types.type import Type
@@ -29,6 +31,10 @@ class Literal(Expression):
     def __str__(self):
         if self.subdenomination:
             return str(convert_subdenomination(self._value, self.subdenomination))
+
+        if self.type in Int + Uint + Fixed + Ufixed + ["address"]:
+            return str(convert_string_to_int(self._value))
+
         # be sure to handle any character
         return str(self._value)
 

slither/core/solidity_types/array_type.py

@@ -53,7 +53,7 @@ class ArrayType(Type):
     def storage_size(self) -> Tuple[int, bool]:
         if self._length_value:
             elem_size, _ = self._type.storage_size
-            return elem_size * int(self._length_value.value), True
+            return elem_size * int(str(self._length_value)), True
         return 32, True
 
     def __str__(self):

slither/slithir/variables/constant.py

@@ -1,4 +1,3 @@
-from decimal import Decimal
 from functools import total_ordering
 
 from slither.core.solidity_types.elementary_type import ElementaryType, Int, Uint
@@ -33,7 +32,7 @@ class Constant(SlithIRVariable):
         else:
             if val.isdigit():
                 self._type = ElementaryType("uint256")
-                self._val = int(Decimal(val))
+                self._val = convert_string_to_int(val)
             else:
                 self._type = ElementaryType("string")
                 self._val = val

slither/solc_parsing/declarations/modifier.py

@@ -62,7 +62,7 @@ class ModifierSolc(FunctionSolc):
         self._content_was_analyzed = True
 
         if self.is_compact_ast:
-            body = self._functionNotParsed["body"]
+            body = self._functionNotParsed.get("body", None)
 
             if body and body[self.get_key()] == "Block":
                 self._function.is_implemented = True

slither/utils/arithmetic.py

@@ -1,17 +1,12 @@
-from decimal import Decimal
-
 from slither.exceptions import SlitherException
+from slither.utils.integer_conversion import convert_string_to_fraction
 
 # pylint: disable=too-many-branches
 def convert_subdenomination(
     value: str, sub: str
 ) -> int:  # pylint: disable=too-many-return-statements
 
-    # to allow 0.1 ether conversion
-    if value[0:2] == "0x":
-        decimal_value = Decimal(int(value, 16))
-    else:
-        decimal_value = Decimal(value)
+    decimal_value = convert_string_to_fraction(value)
     if sub == "wei":
         return int(decimal_value)
     if sub == "gwei":

slither/utils/integer_conversion.py

@@ -1,28 +1,35 @@
-from decimal import Decimal
+from fractions import Fraction
 from typing import Union
 
 from slither.exceptions import SlitherError
 
 
-def convert_string_to_int(val: Union[str, int]) -> int:
+def convert_string_to_fraction(val: Union[str, int]) -> Fraction:
     if isinstance(val, int):
-        return val
+        return Fraction(val)
     if val.startswith(("0x", "0X")):
-        return int(val, 16)
+        return Fraction(int(val, 16))
+
+    # Fractions do not support underscore separators (on Python <3.11)
+    val = val.replace("_", "")
 
     if "e" in val or "E" in val:
         base, expo = val.split("e") if "e" in val else val.split("E")
-        base, expo = Decimal(base), int(expo)
+        base, expo = Fraction(base), int(expo)
         # The resulting number must be < 2**256-1, otherwise solc
         # Would not be able to compile it
         # 10**77 is the largest exponent that fits
         # See https://github.com/ethereum/solidity/blob/9e61f92bd4d19b430cb8cb26f1c7cf79f1dff380/libsolidity/ast/Types.cpp#L1281-L1290
         if expo > 77:
-            if base != Decimal(0):
+            if base != Fraction(0):
                 raise SlitherError(
                     f"{base}e{expo} is too large to fit in any Solidity integer size"
                 )
             return 0
-        return int(Decimal(base) * Decimal(10**expo))
+        return Fraction(base) * Fraction(10**expo)
+
+    return Fraction(val)
 
-    return int(Decimal(val))
+
+def convert_string_to_int(val: Union[str, int]) -> int:
+    return int(convert_string_to_fraction(val))

slither/visitors/expression/constants_folding.py

@@ -1,5 +1,5 @@
 from slither.core.expressions import BinaryOperationType, Literal, UnaryOperationType
-from slither.utils.integer_conversion import convert_string_to_int
+from slither.utils.integer_conversion import convert_string_to_fraction, convert_string_to_int
 from slither.visitors.expression.expression import ExpressionVisitor
 
 
@@ -72,15 +72,15 @@ class ConstantFolding(ExpressionVisitor):
                 cf = ConstantFolding(expr, self._type)
                 expr = cf.result()
             assert isinstance(expr, Literal)
-            set_val(expression, int(expr.value))
+            set_val(expression, -convert_string_to_fraction(expr.value))
         else:
             raise NotConstant
 
     def _post_literal(self, expression):
-        if expression.value.isdigit():
-            set_val(expression, int(expression.value))
-        else:
-            raise NotConstant
+        try:
+            set_val(expression, convert_string_to_fraction(expression.value))
+        except ValueError as e:
+            raise NotConstant from e
 
     def _post_assignement_operation(self, expression):
         raise NotConstant
@@ -115,7 +115,7 @@ class ConstantFolding(ExpressionVisitor):
                 cf = ConstantFolding(expression.expressions[0], self._type)
                 expr = cf.result()
                 assert isinstance(expr, Literal)
-                set_val(expression, int(expr.value))
+                set_val(expression, convert_string_to_fraction(expr.value))
                 return
         raise NotConstant