fix: reorder AST folding after semantics validation

tests/ast/nodes/test_evaluate_binop_decimal.py

@@ -19,6 +19,7 @@
 @example(left=Decimal("0.0000000001"), right=Decimal("0.9999999999"))
 @example(left=Decimal("0.9999999999"), right=Decimal("0.9999999999"))
 @example(left=Decimal("0.0000000001"), right=Decimal("0.0000000001"))
+@example(left=Decimal("0.0000000001"), right=Decimal("0.0000000000"))
 @pytest.mark.parametrize("op", "+-*/%")
 def test_binop_decimal(get_contract, assert_tx_failed, op, left, right):
     source = f"""

tests/ast/nodes/test_evaluate_binop_int.py

@@ -15,6 +15,7 @@
 @example(left=1, right=-1)
 @example(left=-1, right=1)
 @example(left=-1, right=-1)
+@example(left=1, right=0)
 @pytest.mark.parametrize("op", "+-*/%")
 def test_binop_int128(get_contract, assert_tx_failed, op, left, right):
     source = f"""

tests/ast/nodes/test_evaluate_compare.py

@@ -47,7 +47,7 @@ def foo(a: uint128, b: uint128) -> bool:
 
 
 @pytest.mark.fuzzing
-@settings(max_examples=20, deadline=500)
+@settings(max_examples=20, deadline=2500)
 @given(left=st.integers(), right=st.lists(st.integers(), min_size=1, max_size=16))
 def test_compare_in(left, right, get_contract):
     source = f"""
@@ -66,7 +66,7 @@ def foo(a: int128, b: int128[{len(right)}]) -> bool:
 
 
 @pytest.mark.fuzzing
-@settings(max_examples=20, deadline=500)
+@settings(max_examples=20, deadline=2500)
 @given(left=st.integers(), right=st.lists(st.integers(), min_size=1, max_size=16))
 def test_compare_not_in(left, right, get_contract):
     source = f"""

tests/functional/context/types/test_type_from_annotation.py

@@ -1,11 +1,6 @@
 import pytest
 
-from vyper.exceptions import (
-    ArrayIndexException,
-    InvalidType,
-    StructureException,
-    UndeclaredDefinition,
-)
+from vyper.exceptions import ArrayIndexException, InvalidType, StructureException
 from vyper.semantics.types import get_primitive_types
 from vyper.semantics.types.bases import DataLocation
 from vyper.semantics.types.indexable.mapping import MappingDefinition
@@ -74,9 +69,7 @@ def test_base_types_as_multidimensional_arrays(build_node, namespace, type_str):
 @pytest.mark.parametrize("idx", ["0", "-1", "0x00", "'1'", "foo", "[1]", "(1,)"])
 def test_invalid_index(build_node, idx, type_str):
     node = build_node(f"{type_str}[{idx}]")
-    with pytest.raises(
-        (ArrayIndexException, InvalidType, StructureException, UndeclaredDefinition)
-    ):
+    with pytest.raises((ArrayIndexException, InvalidType)):
         get_type_from_annotation(node, DataLocation.STORAGE)
 
 

tests/functions/folding/test_abs.py

@@ -4,7 +4,7 @@
 
 from vyper import ast as vy_ast
 from vyper import builtin_functions as vy_fn
-from vyper.exceptions import OverflowException
+from vyper.exceptions import InvalidType, OverflowException
 
 
 @pytest.mark.fuzzing
@@ -29,14 +29,22 @@ def foo(a: int256) -> int256:
 @pytest.mark.fuzzing
 @settings(max_examples=50, deadline=1000)
 @given(a=st.integers(min_value=2 ** 255, max_value=2 ** 256 - 1))
-def test_abs_upper_bound_folding(get_contract, a):
+def test_abs_upper_bound_folded_1(get_contract, assert_compile_failed, a):
     source = f"""
 @external
-def foo(a: int256) -> int256:
+def foo() -> int256:
     return abs({a})
     """
-    with pytest.raises(OverflowException):
-        get_contract(source)
+    assert_compile_failed(lambda: get_contract(source), InvalidType)
+
+
+def test_abs_upper_bound_folded_2(get_contract, assert_compile_failed):
+    source = """
+@external
+def foo() -> int256:
+    return abs(2**256)
+    """
+    assert_compile_failed(lambda: get_contract(source), OverflowException)
 
 
 def test_abs_lower_bound(get_contract, assert_tx_failed):
@@ -50,11 +58,10 @@ def foo(a: int256) -> int256:
     assert_tx_failed(lambda: contract.foo(-(2 ** 255)))
 
 
-def test_abs_lower_bound_folded(get_contract, assert_tx_failed):
+def test_abs_lower_bound_folded(get_contract, assert_compile_failed):
     source = """
 @external
 def foo() -> int256:
     return abs(-2**255)
     """
-    with pytest.raises(OverflowException):
-        get_contract(source)
+    assert_compile_failed(lambda: get_contract(source), OverflowException)

tests/functions/folding/test_shift.py

@@ -0,0 +1,27 @@
+import pytest
+from hypothesis import given, settings
+from hypothesis import strategies as st
+
+from vyper import ast as vy_ast
+from vyper import builtin_functions as vy_fn
+
+st_uint256 = st.integers(min_value=0, max_value=256)
+st_int128 = st.integers(min_value=-128, max_value=127)
+
+
+@pytest.mark.fuzzing
+@settings(max_examples=100, deadline=1000)
+@given(a=st_uint256, b=st_int128)
+def test_shift_uint256(get_contract, a, b):
+    source = """
+@external
+def foo(a: uint256, b: int128) -> uint256:
+    return shift(a, b)
+    """
+    contract = get_contract(source)
+
+    vyper_ast = vy_ast.parse_to_ast(f"shift({a}, {b})")
+    old_node = vyper_ast.body[0].value
+    new_node = vy_fn.Shift().evaluate(old_node)
+
+    assert contract.foo(a, b) == new_node.value

tests/parser/exceptions/test_argument_exception.py

@@ -6,11 +6,6 @@
 fail_list = [
     """
 @external
-def foo():
-    x = as_wei_value(5, "vader")
-    """,
-    """
-@external
 def foo(x: int128, x: int128): pass
     """,
     """

tests/parser/exceptions/test_undeclared_definition.py

@@ -61,6 +61,11 @@ def foo():
 def foo():
     bork = zork
     """,
+    """
+@external
+def foo():
+    x = as_wei_value(5, "vader")
+    """,
 ]
 
 

tests/parser/features/external_contracts/test_external_contract_calls.py

@@ -379,7 +379,7 @@ def test_int128_too_long(get_contract, assert_tx_failed):
     contract_1 = """
 @external
 def foo() -> int256:
-    return (2**255)-1
+    return 2**254
     """
 
     c = get_contract(contract_1)

tests/parser/features/iteration/test_for_in_list.py

@@ -8,6 +8,7 @@
     InvalidType,
     IteratorException,
     NamespaceCollision,
+    OverflowException,
     StateAccessViolation,
     StructureException,
     TypeMismatch,
@@ -686,13 +687,16 @@ def foo():
     """,
         StateAccessViolation,
     ),
-    """
+    (
+        """
 @external
 def foo():
     a: int128 = 6
     for i in range(a,a-3):
         pass
     """,
+        StructureException,
+    ),
     # invalid argument length
     (
         """
@@ -758,7 +762,7 @@ def test_for() -> int128:
         a = i
     return a
     """,
-        TypeMismatch,
+        OverflowException,
     ),
     (
         """

tests/parser/functions/test_bitwise.py

@@ -2,7 +2,7 @@
 
 from vyper.compiler import compile_code
 from vyper.evm.opcodes import EVM_VERSIONS
-from vyper.exceptions import TypeMismatch
+from vyper.exceptions import InvalidLiteral, InvalidType, OverflowException, TypeMismatch
 
 code = """
 @external
@@ -136,10 +136,81 @@ def foo(x: uint8, y: int128) -> uint256:
     return shift(x, y)
     """,
         TypeMismatch,
+    ),
+    (
+        """
+@external
+def foo():
+    a: uint256 = shift(
+        115792089237316195423570985008687907853269984665640564039457584007913129639936,
+        2
     )
+    """,
+        OverflowException,
+    ),
+    (
+        """
+@external
+def foo():
+    a: uint256 = shift(-1, 2)
+    """,
+        TypeMismatch,
+    ),
+    (
+        """
+@external
+def foo():
+    a: uint256 = shift(1, 170141183460469231731687303715884105728)
+    """,
+        InvalidLiteral,
+    ),
 ]
 
 
 @pytest.mark.parametrize("bad_code,exc", fail_list)
 def test_shift_fail(get_contract_with_gas_estimation, bad_code, exc, assert_compile_failed):
     assert_compile_failed(lambda: get_contract_with_gas_estimation(bad_code), exc)
+
+
+@pytest.mark.parametrize("op", ["bitwise_and", "bitwise_or", "bitwise_xor"])
+def test_bitwise_fail(get_contract_with_gas_estimation, assert_compile_failed, op):
+    # 2 ** 256 is out of all numeric bounds
+    c1 = f"""
+@external
+def foo():
+    a: uint256 = {op}(
+        1,
+        115792089237316195423570985008687907853269984665640564039457584007913129639936
+    )
+    """
+
+    # Negative integers are not allowed
+    c2 = f"""
+@external
+def foo():
+    a: uint256 = {op}(-1, 1)
+    """
+
+    assert_compile_failed(lambda: get_contract_with_gas_estimation(c1), OverflowException)
+    assert_compile_failed(lambda: get_contract_with_gas_estimation(c2), InvalidType)
+
+
+def test_bitwise_not_fail(get_contract_with_gas_estimation, assert_compile_failed):
+    # 2 ** 256 is out of all numeric bounds
+    c1 = """
+@external
+def foo():
+    a: uint256 = bitwise_not(
+        115792089237316195423570985008687907853269984665640564039457584007913129639936
+    )
+    """
+
+    # Negative integers are not allowed
+    c2 = """
+@external
+def foo():
+    a: uint256 = bitwise_not(-1)
+    """
+
+    assert_compile_failed(lambda: get_contract_with_gas_estimation(c1), OverflowException)
+    assert_compile_failed(lambda: get_contract_with_gas_estimation(c2), InvalidType)

tests/parser/functions/test_interfaces.py

@@ -318,7 +318,7 @@ def ok() -> {typ}:
 
 @external
 def should_fail() -> int256:
-    return -2**255 # OOB for all int/uint types with less than 256 bits
+    return -2**254 # OOB for all int/uint types with less than 256 bits
     """
 
     code = f"""
@@ -358,7 +358,7 @@ def test_fail3() -> int256:
         interface_codes={"BadCode": {"type": "vyper", "code": external_contract}},
     )
     assert bad_c.ok() == 1
-    assert bad_c.should_fail() == -(2 ** 255)
+    assert bad_c.should_fail() == -(2 ** 254)
 
     assert c.test_ok() == 1
     assert_tx_failed(lambda: c.test_fail())

tests/parser/functions/test_minmax.py

@@ -259,3 +259,19 @@ def foo4() -> int128:
     assert c.foo2() == -(2 ** 127)
     assert c.foo3() == 2 ** 127 - 1
     assert c.foo4() == 2 ** 127 - 1
+
+
+def test_minmax_in_constant(get_contract_with_gas_estimation):
+    code = """
+a: constant(uint256) = max(10, 20)
+b: constant(uint256) = min(10, 20)
+c: constant(uint256) = max(min(10, 20), max(30, 40))
+d: constant(uint256) = max(10, 20 + 57)
+e: constant(uint256) = min(10 - 5, 7)
+
+@external
+def foo() -> (uint256, uint256, uint256, uint256, uint256):
+    return a, b, c, d, e
+    """
+    c = get_contract_with_gas_estimation(code)
+    assert c.foo() == [20, 10, 40, 77, 5]

tests/parser/functions/test_minmax_value.py

@@ -6,7 +6,7 @@
     parse_decimal_info,
     parse_integer_typeinfo,
 )
-from vyper.exceptions import InvalidType, OverflowException
+from vyper.exceptions import OverflowException
 from vyper.utils import int_bounds
 
 
@@ -42,15 +42,8 @@ def foo():
     a: {typ} = min_value({typ}) - 1
     """
 
-    if typ == "uint256":
-        assert_compile_failed(lambda: get_contract(upper), OverflowException)
-    else:
-        assert_compile_failed(lambda: get_contract(upper), InvalidType)
-
-    if typ == "int256":
-        assert_compile_failed(lambda: get_contract(lower), OverflowException)
-    else:
-        assert_compile_failed(lambda: get_contract(lower), InvalidType)
+    assert_compile_failed(lambda: get_contract(upper), OverflowException)
+    assert_compile_failed(lambda: get_contract(lower), OverflowException)
 
 
 @pytest.mark.parametrize("typ", sorted(DECIMAL_TYPES))

tests/parser/functions/test_unary.py

@@ -68,11 +68,11 @@ def bar() -> decimal:
 
 def test_negation_int128(get_contract):
     code = """
-a: constant(int128) = -2**127
+a: constant(int128) = MIN_INT128
 
 @external
 def foo() -> int128:
-    return -2**127
+    return MIN_INT128
 
 @external
 def bar() -> int128: