Folding builtins

tests/ast/test_folding.py

@@ -189,3 +189,26 @@ def test_replace_userdefined_constant_no(source):
     folding.replace_user_defined_constants(folded_ast)
 
     assert vy_ast.compare_nodes(unmodified_ast, folded_ast)
+
+
+builtin_folding_functions = [("ceil(4.2)", "5"), ("floor(4.2)", "4")]
+
+builtin_folding_sources = [
+    "{}",
+    "foo = {}",
+    "foo = [{0}, {0}]",
+    "def foo(): {}",
+    "def foo(): return {}",
+    "def foo(bar: {}): pass",
+]
+
+
+@pytest.mark.parametrize("source", builtin_folding_sources)
+@pytest.mark.parametrize("original,result", builtin_folding_functions)
+def test_replace_builtins(source, original, result):
+    original_ast = vy_ast.parse_to_ast(source.format(original))
+    target_ast = vy_ast.parse_to_ast(source.format(result))
+
+    folding.replace_builtin_functions(original_ast)
+
+    assert vy_ast.compare_nodes(original_ast, target_ast)

tests/functions/folding/test_addmod_mulmod.py

@@ -0,0 +1,35 @@
+from hypothesis import (
+    assume,
+    given,
+    settings,
+    strategies as st,
+)
+import pytest
+
+from vyper import (
+    ast as vy_ast,
+    functions as vy_fn,
+)
+
+st_uint256 = st.integers(min_value=0, max_value=2 ** 256 - 1)
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=50, deadline=1000)
+@given(a=st_uint256, b=st_uint256, c=st_uint256)
+@pytest.mark.parametrize('fn_name', ['uint256_addmod', 'uint256_mulmod'])
+def test_modmath(get_contract, a, b, c, fn_name):
+    assume(c > 0)
+
+    source = f"""
+@public
+def foo(a: uint256, b: uint256, c: uint256) -> uint256:
+    return {fn_name}(a, b, c)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({a}, {b}, {c})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+
+    assert contract.foo(a, b, c) == new_node.value

tests/functions/folding/test_bitwise.py

@@ -0,0 +1,71 @@
+from hypothesis import (
+    given,
+    settings,
+    strategies as st,
+)
+import pytest
+
+from vyper import (
+    ast as vy_ast,
+    functions as vy_fn,
+)
+
+st_uint256 = st.integers(min_value=0, max_value=2 ** 256 - 1)
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=50, deadline=1000)
+@given(a=st_uint256, b=st_uint256)
+@pytest.mark.parametrize('fn_name', ['bitwise_and', 'bitwise_or', 'bitwise_xor'])
+def test_bitwise(get_contract, a, b, fn_name):
+
+    source = f"""
+@public
+def foo(a: uint256, b: uint256) -> uint256:
+    return {fn_name}(a, b)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({a}, {b})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+
+    assert contract.foo(a, b) == new_node.value
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=50, deadline=1000)
+@given(value=st_uint256)
+def test_bitwise_not(get_contract, value):
+
+    source = f"""
+@public
+def foo(a: uint256) -> uint256:
+    return bitwise_not(a)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"bitwise_not({value})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.BitwiseNot().evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=50, deadline=1000)
+@given(value=st_uint256, steps=st.integers(min_value=-256, max_value=256))
+def test_shift(get_contract, value, steps):
+
+    source = f"""
+@public
+def foo(a: uint256, b: int128) -> uint256:
+    return shift(a, b)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"shift({value}, {steps})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.Shift().evaluate(old_node)
+
+    assert contract.foo(value, steps) == new_node.value

tests/functions/folding/test_floor_ceil.py

@@ -0,0 +1,47 @@
+from decimal import (
+    Decimal,
+)
+
+from hypothesis import (
+    example,
+    given,
+    settings,
+    strategies as st,
+)
+import pytest
+
+from vyper import (
+    ast as vy_ast,
+    functions as vy_fn,
+)
+
+st_decimals = st.decimals(
+    min_value=-(2 ** 32),
+    max_value=2 ** 32,
+    allow_nan=False,
+    allow_infinity=False,
+    places=10,
+)
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=50, deadline=1000)
+@given(value=st_decimals)
+@example(value=Decimal("0.9999999999"))
+@example(value=Decimal("0.0000000001"))
+@example(value=Decimal("-0.9999999999"))
+@example(value=Decimal("-0.0000000001"))
+@pytest.mark.parametrize("fn_name", ["floor", "ceil"])
+def test_floor_ceil(get_contract, value, fn_name):
+    source = f"""
+@public
+def foo(a: decimal) -> int128:
+    return {fn_name}(a)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({value})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value

tests/functions/folding/test_fold_as_wei_value.py

@@ -0,0 +1,60 @@
+from hypothesis import (
+    given,
+    settings,
+    strategies as st,
+)
+import pytest
+
+from vyper import (
+    ast as vy_ast,
+    functions as vy_fn,
+)
+
+denoms = [x for k in vy_fn.AsWeiValue.wei_denoms.keys() for x in k]
+
+
+st_decimals = st.decimals(
+    min_value=0,
+    max_value=2 ** 32,
+    allow_nan=False,
+    allow_infinity=False,
+    places=10,
+)
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=10, deadline=1000)
+@given(value=st_decimals)
+@pytest.mark.parametrize('denom', denoms)
+def test_decimal(get_contract, value, denom):
+    source = f"""
+@public
+def foo(a: decimal) -> uint256:
+    return as_wei_value(a, '{denom}')
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"as_wei_value({value:.10f}, '{denom}')")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.AsWeiValue().evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=10, deadline=1000)
+@given(value=st.integers(min_value=0, max_value=2 ** 128))
+@pytest.mark.parametrize('denom', denoms)
+def test_integer(get_contract, value, denom):
+    source = f"""
+@public
+def foo(a: uint256) -> uint256:
+    return as_wei_value(a, '{denom}')
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"as_wei_value({value}, '{denom}')")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.AsWeiValue().evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value

tests/functions/folding/test_keccak_sha.py

@@ -0,0 +1,73 @@
+from hypothesis import (
+    given,
+    settings,
+    strategies as st,
+)
+import pytest
+
+from vyper import (
+    ast as vy_ast,
+    functions as vy_fn,
+)
+
+alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&()*+,-./:;<=>?@[]^_`{|}~'  # NOQA: E501
+
+
+@pytest.mark.fuzzing
+@given(value=st.text(alphabet=alphabet, min_size=0, max_size=100))
+@settings(max_examples=50, deadline=1000)
+@pytest.mark.parametrize('fn_name', ['keccak256', 'sha256'])
+def test_string(get_contract, value, fn_name):
+
+    source = f"""
+@public
+def foo(a: string[100]) -> bytes32:
+    return {fn_name}(a)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"{fn_name}('''{value}''')")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value
+
+
+@pytest.mark.fuzzing
+@given(value=st.binary(min_size=0, max_size=100))
+@settings(max_examples=50, deadline=1000)
+@pytest.mark.parametrize('fn_name', ['keccak256', 'sha256'])
+def test_bytes(get_contract, value, fn_name):
+    source = f"""
+@public
+def foo(a: bytes[100]) -> bytes32:
+    return {fn_name}(a)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({value})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value
+
+
+@pytest.mark.fuzzing
+@given(value=st.binary(min_size=1, max_size=100))
+@settings(max_examples=50, deadline=1000)
+@pytest.mark.parametrize('fn_name', ['keccak256', 'sha256'])
+def test_hex(get_contract, value, fn_name):
+    source = f"""
+@public
+def foo(a: bytes[100]) -> bytes32:
+    return {fn_name}(a)
+    """
+    contract = get_contract(source)
+
+    value = f"0x{value.hex()}"
+
+    vyper_ast = vy_ast.parse_to_ast(f"{fn_name}({value})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.DISPATCH_TABLE[fn_name].evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value

tests/functions/folding/test_len.py

@@ -0,0 +1,60 @@
+import pytest
+
+from vyper import (
+    ast as vy_ast,
+    functions as vy_fn,
+)
+
+
+@pytest.mark.parametrize("length", [0, 1, 32, 33, 64, 65, 1024])
+def test_len_string(get_contract, length):
+    source = f"""
+@public
+def foo(a: string[1024]) -> int128:
+    return len(a)
+    """
+    contract = get_contract(source)
+
+    value = "a" * length
+
+    vyper_ast = vy_ast.parse_to_ast(f"len('{value}')")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.Len().evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value
+
+
+@pytest.mark.parametrize("length", [0, 1, 32, 33, 64, 65, 1024])
+def test_len_bytes(get_contract, length):
+    source = f"""
+@public
+def foo(a: bytes[1024]) -> int128:
+    return len(a)
+    """
+    contract = get_contract(source)
+
+    value = "a" * length
+
+    vyper_ast = vy_ast.parse_to_ast(f"len(b'{value}')")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.Len().evaluate(old_node)
+
+    assert contract.foo(value.encode()) == new_node.value
+
+
+@pytest.mark.parametrize("length", [1, 32, 33, 64, 65, 1024])
+def test_len_hex(get_contract, length):
+    source = f"""
+@public
+def foo(a: bytes[1024]) -> int128:
+    return len(a)
+    """
+    contract = get_contract(source)
+
+    value = f"0x{'00' * length}"
+
+    vyper_ast = vy_ast.parse_to_ast(f"len({value})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.Len().evaluate(old_node)
+
+    assert contract.foo(value) == new_node.value