feat[venom]: inline pass and call conv

tests/unit/compiler/asm/test_asm_optimizer.py

@@ -120,7 +120,9 @@ def foo():
     input_bundle = make_input_bundle({"library.vy": library})
     res = compile_code(code, input_bundle=input_bundle, output_formats=["asm"])
     asm = res["asm"]
-    assert "some_function()" in asm
+
+    if not experimental_codegen:
+        assert "some_function()" in asm  # Venom function inliner will remove this
 
     assert "unused1()" not in asm
     assert "unused2()" not in asm

tests/unit/compiler/test_source_map.py

@@ -38,16 +38,23 @@ def test_jump_map(optimize, experimental_codegen):
     jump_map = source_map["pc_jump_map"]
 
     expected_jumps = 1
+    expected_internals = 2
     if optimize == OptimizationLevel.NONE:
         # some jumps which don't get optimized out when optimizer is off
         # (slightly different behavior depending if venom pipeline is enabled):
         if not experimental_codegen:
             expected_jumps = 3
         else:
             expected_jumps = 2
+    else:
+        if not experimental_codegen:
+            expected_internals = 2
+        else:
+            expected_jumps = 0
+            expected_internals = 0
 
     assert len([v for v in jump_map.values() if v == "o"]) == expected_jumps
-    assert len([v for v in jump_map.values() if v == "i"]) == 2
+    assert len([v for v in jump_map.values() if v == "i"]) == expected_internals
 
     code_lines = [i + "\n" for i in TEST_CODE.split("\n")]
     for pc in [k for k, v in jump_map.items() if v == "o"]:

tests/unit/compiler/venom/test_call_conv.py

@@ -0,0 +1,112 @@
+def test_simple_call(get_contract):
+    code = """
+@internal
+def name(_name: uint256) -> uint256:
+    return _name + 1
+
+
+@external
+def foo(x: uint256) -> uint256:
+    u: uint256 = 1 + x
+    ret: uint256 = self.name(u + 10)
+    return ret
+    """
+
+    c = get_contract(code)
+    assert c.foo(1) == 13
+
+
+def test_simple_call_multiple_args_in_call(get_contract):
+    code = """
+@internal
+def bar(_name: uint256, _name2: uint256) -> uint256:
+    return _name + 10
+
+@external
+def foo(x: uint256) -> uint256:
+    ret: uint256 = self.bar(20, 10)
+    return ret
+    """
+
+    c = get_contract(code)
+    assert c.foo(1) == 30
+
+
+def test_simple_call_multiple_args(get_contract):
+    code = """
+@internal
+def bar(_name: uint256, _name2: uint256) -> (uint256, uint256):
+    return _name + 1, _name + 2
+
+@external
+def foo(x: uint256) -> (uint256, uint256):
+    ret: (uint256, uint256) = self.bar(20, 10)
+    return ret
+    """
+
+    c = get_contract(code)
+    assert c.foo(1) == (21, 22)
+
+
+def test_call_in_call(get_contract):
+    code = """
+@internal
+def _foo(a: uint256) -> uint256:
+    return a
+
+@external
+def foo() -> uint256:
+    a: uint256 = 1
+    return self._foo(a)
+"""
+
+    c = get_contract(code)
+
+    assert c.foo() == 1
+
+
+def test_2d_array_input_1(get_contract):
+    code = """
+@internal
+def test_input(arr: DynArray[DynArray[int128, 2], 1]) -> DynArray[DynArray[int128, 2], 1]:
+    return arr
+
+@external
+def test_values(arr: DynArray[DynArray[int128, 2], 1]) -> DynArray[DynArray[int128, 2], 1]:
+    return self.test_input(arr)
+    """
+
+    c = get_contract(code)
+    assert c.test_values([[1, 2]]) == ([[1, 2]])
+
+
+def test_call_with_unused_params(get_contract):
+    code = """
+@internal
+def _foo3(a: uint256, b: uint256) -> uint256:
+    return 42
+
+@external
+def foo() -> uint256:
+    return self._foo3(9, 11)
+    """
+
+    c = get_contract(code)
+
+    assert c.foo() == 42
+
+
+def test_internal_assign(get_contract):
+    code = """
+@internal
+def foo(x: uint256) -> uint256:
+    x = 10
+    return x
+
+@external
+def bar(x: uint256) -> uint256:
+    return self.foo(x)
+    """
+    c = get_contract(code)
+
+    assert c.bar(70) == 10