feat[venom]: add binop optimizations (vyperlang#4281)

this commit adds additional binop optimizations to venom. these are
the analog of `optimize_binop` in the legacy optimizer and take us one
step closer to being able to bypass the legacy optimizer in the venom
pipeline.

the rules have been added to the algebraic optimizations pass. adding
them to the SCCP pass was considered, but to keep the rules all in one
place and to keep each pass more self-contained, they were added to the
algebraic optimizations pass, with additional SCCP passes performed for
branch/cfg reduction.

some additional machinery has been added, including `lit_eq` which
compares two IRLiterals in modular arithmetic, and InstructionUpdator,
which updates instructions while also updating the DFG in-place. this
should be useful to use for other passes in the future (although out of
scope for this PR).

additional passes have been added since they were found to improve
codesize. in particular, running AlgebraicOptimization multiple times,
and running SCCP after LoadElimination, seem to have some additional
benefits.

---------

Co-authored-by: Charles Cooper <[email protected]>

tests/functional/builtins/codegen/test_slice.py

@@ -5,7 +5,12 @@
 from vyper.compiler import compile_code
 from vyper.compiler.settings import OptimizationLevel, Settings
 from vyper.evm.opcodes import version_check
-from vyper.exceptions import ArgumentException, CompilerPanic, TypeMismatch
+from vyper.exceptions import (
+    ArgumentException,
+    CompilerPanic,
+    StaticAssertionException,
+    TypeMismatch,
+)
 
 _fun_bytes32_bounds = [(0, 32), (3, 29), (27, 5), (0, 5), (5, 3), (30, 2)]
 
@@ -533,9 +538,15 @@ def do_slice():
 
 @pytest.mark.parametrize("bad_code", oob_fail_list)
 def test_slice_buffer_oob_reverts(bad_code, get_contract, tx_failed):
-    c = get_contract(bad_code)
-    with tx_failed():
-        c.do_slice()
+    try:
+        c = get_contract(bad_code)
+        with tx_failed():
+            c.do_slice()
+    except StaticAssertionException:
+        # it should be ok if we
+        # catch the assert in compile time
+        # since it supposed to be revert
+        pass
 
 
 # tests all 3 adhoc locations: `msg.data`, `self.code`, `<address>.code`

tests/functional/codegen/features/test_clampers.py

@@ -5,7 +5,6 @@
 from eth_utils import keccak
 
 from tests.utils import ZERO_ADDRESS, decimal_to_int
-from vyper.exceptions import StackTooDeep
 from vyper.utils import int_bounds
 
 
@@ -502,7 +501,6 @@ def foo(b: DynArray[int128, 10]) -> DynArray[int128, 10]:
 
 
 @pytest.mark.parametrize("value", [0, 1, -1, 2**127 - 1, -(2**127)])
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_multidimension_dynarray_clamper_passing(get_contract, value):
     code = """
 @external

tests/functional/codegen/types/test_dynamic_array.py

@@ -14,6 +14,7 @@
     ImmutableViolation,
     OverflowException,
     StateAccessViolation,
+    StaticAssertionException,
     TypeMismatch,
 )
 
@@ -1863,9 +1864,16 @@ def should_revert() -> DynArray[String[65], 2]:
 @pytest.mark.parametrize("code", dynarray_length_no_clobber_cases)
 def test_dynarray_length_no_clobber(get_contract, tx_failed, code):
     # check that length is not clobbered before dynarray data copy happens
-    c = get_contract(code)
-    with tx_failed():
-        c.should_revert()
+    try:
+        c = get_contract(code)
+        with tx_failed():
+            c.should_revert()
+    except StaticAssertionException:
+        # this test should create
+        # assert error so if it is
+        # detected in compile time
+        # we can continue
+        pass
 
 
 def test_dynarray_make_setter_overlap(get_contract):

tests/functional/syntax/test_unbalanced_return.py

@@ -195,7 +195,7 @@ def test() -> int128:
     if 1 == 1 :
         return 1
     else:
-        assert msg.sender != msg.sender
+        assert msg.sender != self
         return 0
     """,
     """