feat: add extend for dynamic arrays

docs/types.rst

@@ -494,6 +494,14 @@ Dynamic arrays represent bounded arrays whose length can be modified at runtime,
     exampleList.append(120)  # exampleList now has length 2
     exampleList.append(356)  # exampleList now has length 3
     # exampleList.append(1)  # would revert!
+    anotherList: DynArray[int128, 3] = []
+    anotherList.extend(exampleList)  # anotherList now has length 3
+    longerList: DynArray[int128, 5] = [1]
+    longerList.extend(exampleList)  # longerList now has length 4
+    failList: DynArray[int128, 3] = [1]
+    failList.extend(exampleList)  # would revert because max length of failList is exceeded!
+    shortList: DynArray[int128, 2] = []
+    shortList.extend(exampleList)  # will not compile!
 
     myValue: int128 = exampleList.pop()  # myValue == 356, exampleList now has length 2
 

tests/parser/types/test_dynamic_array.py

@@ -1222,6 +1222,174 @@ def test_append_pop_complex(get_contract, assert_tx_failed, code_template, check
         """
         code = struct_def + "\n" + code
 
+    c = get_contract(code)
+    expected_result = check_result(test_data)
+    if expected_result is None:
+        # None is sentinel to indicatecool, I'd txn should revert
+        assert_tx_failed(lambda: c.foo(test_data))
+    else:
+        assert c.foo(test_data) == expected_result
+
+
+@pytest.mark.parametrize("subtyp", ["uint8", "int128", "uint256"])
+def test_extend_literal(get_contract, subtyp):
+    data = [1, 2, 3]
+    if subtyp == "int128":
+        data = [-1, 2, 3]
+    code = f"""
+@external
+def foo() -> DynArray[{subtyp}, 3]:
+    x: DynArray[{subtyp}, 3] = []
+    a: DynArray[{subtyp}, 3] = [{data[0]}]
+    x.extend(a)
+    b: DynArray[{subtyp}, 3] = [{data[1]}]
+    x.extend(b)
+    c: DynArray[{subtyp}, 3] = [{data[2]}]
+    x.extend(c)
+    return x
+    """
+    c = get_contract(code)
+    assert c.foo() == data
+
+
+def test_extend_invalid_length(get_contract, assert_compile_failed):
+    code = """
+@external
+def foo() -> DynArray[uint256, 3]:
+    x: DynArray[uint256, 3] = []
+    y: DynArray[uint256, 4] = []
+    x.extend(y)
+    return x
+    """
+    assert_compile_failed(lambda: get_contract(code), TypeMismatch)
+
+
+def test_extend_valid_length(get_contract):
+    code = """
+@external
+def foo(y: DynArray[uint256, 3]) -> DynArray[uint256, 5]:
+    x: DynArray[uint256, 5] = [1, 2]
+    x.extend(y)
+    return x
+    """
+    c = get_contract(code)
+    assert c.foo([3, 4]) == [1, 2, 3, 4]
+
+
+def test_extend_empty(get_contract):
+    code = """
+@external
+def foo(y: DynArray[uint256, 3]) -> DynArray[uint256, 3]:
+    x: DynArray[uint256, 3] = [1, 2, 3]
+    x.extend(y)
+    return x
+    """
+    c = get_contract(code)
+    assert c.foo([]) == [1, 2, 3]
+
+
+def test_extend_length_clamp(get_contract, assert_tx_failed):
+    code = """
+@external
+def foo(y: DynArray[uint256, 2]) -> DynArray[uint256, 3]:
+    x: DynArray[uint256, 3] = [1, 2]
+    x.extend(y)
+    return x
+    """
+    c = get_contract(code)
+    assert_tx_failed(lambda: c.foo([3, 4]))
+
+
+extend_pop_tests = [
+    (
+        """
+my_array: DynArray[uint256, 5]
+@external
+def foo(xs: DynArray[uint256, 5]) -> DynArray[uint256, 5]:
+    self.my_array.extend(xs)
+    return self.my_array
+    """,
+        lambda xs: xs,
+    ),
+    (
+        """
+my_array: DynArray[uint256, 5]
+@external
+def foo(xs: DynArray[uint256, 5]) -> DynArray[uint256, 5]:
+    self.my_array.extend(xs)
+    for x in xs:
+        self.my_array.pop()
+    return self.my_array
+    """,
+        lambda xs: [],
+    ),
+    # check order of evaluation.
+    (
+        """
+my_array: DynArray[uint256, 5]
+@external
+def foo(xs: DynArray[uint256, 5]) -> (DynArray[uint256, 5], uint256):
+    self.my_array.extend(xs)
+    return self.my_array, self.my_array.pop()
+    """,
+        lambda xs: None if len(xs) == 0 else [xs, xs[-1]],
+    ),
+    # check order of evaluation.
+    (
+        """
+my_array: DynArray[uint256, 5]
+@external
+def foo(xs: DynArray[uint256, 5]) -> (uint256, DynArray[uint256, 5]):
+    self.my_array.extend(xs)
+    return self.my_array.pop(), self.my_array
+    """,
+        lambda xs: None if len(xs) == 0 else [xs[-1], xs[:-1]],
+    ),
+    # test memory arrays
+    (
+        """
+@external
+def foo(xs: DynArray[uint256, 5]) -> DynArray[uint256, 5]:
+    ys: DynArray[uint256, 5] = []
+    ys.extend(xs)
+    return ys
+    """,
+        lambda xs: xs,
+    ),
+    # pop to 0 elems
+    (
+        """
+@external
+def foo(xs: DynArray[uint256, 5]) -> DynArray[uint256, 5]:
+    ys: DynArray[uint256, 5] = []
+    ys.extend(xs)
+    for x in xs:
+        ys.pop()
+    return ys
+    """,
+        lambda xs: [],
+    ),
+    # check underflow
+    (
+        """
+@external
+def foo(xs: DynArray[uint256, 5]) -> DynArray[uint256, 5]:
+    ys: DynArray[uint256, 5] = []
+    ys.extend(xs)
+    for x in xs:
+        ys.pop()
+    ys.pop()  # fail
+    return ys
+    """,
+        lambda xs: None,
+    ),
+]
+
+
+@pytest.mark.parametrize("code,check_result", extend_pop_tests)
+# TODO change this to fuzz random data
+@pytest.mark.parametrize("test_data", [[1, 2, 3, 4, 5][:i] for i in range(6)])
+def test_extend_pop(get_contract, assert_tx_failed, code, check_result, test_data):
     c = get_contract(code)
     expected_result = check_result(test_data)
     if expected_result is None:
@@ -1231,6 +1399,101 @@ def test_append_pop_complex(get_contract, assert_tx_failed, code_template, check
         assert c.foo(test_data) == expected_result
 
 
+invalid_extend_pop = [
+    (
+        """
+my_array: DynArray[uint256, 5]
+@external
+def foo(xs: DynArray[uint256, 6]) -> DynArray[uint256, 5]:
+    self.my_array.extend(xs)
+    return self.my_array
+    """,
+        TypeMismatch,  # Size of src darray is greater than dst darray
+    )
+]
+
+
+@pytest.mark.parametrize("code,exception_type", invalid_extend_pop)
+def test_invalid_extend_pop(get_contract, assert_compile_failed, code, exception_type):
+    assert_compile_failed(lambda: get_contract(code), exception_type)
+
+
+extend_pop_complex_tests = [
+    (
+        """
+@external
+def foo(x: {typ}) -> DynArray[{typ}, 2]:
+    ys: DynArray[{typ}, 1] = []
+    temp: DynArray[{typ}, 1] = [x]
+    ys.extend(temp)
+    return ys
+    """,
+        lambda x: [x],
+    ),
+    (
+        """
+my_array: DynArray[{typ}, 1]
+@external
+def foo(x: {typ}) -> DynArray[{typ}, 2]:
+    temp: DynArray[{typ}, 1] = [x]
+    self.my_array.extend(temp)
+    self.my_array.extend(temp)  # fail
+    return self.my_array
+    """,
+        lambda x: None,
+    ),
+    (
+        """
+my_array: DynArray[{typ}, 5]
+@external
+def foo(x: {typ}) -> (DynArray[{typ}, 5], {typ}):
+    temp: DynArray[{typ}, 1] = [x]
+    self.my_array.extend(temp)
+    return self.my_array, self.my_array.pop()
+    """,
+        lambda x: [[x], x],
+    ),
+    (
+        """
+my_array: DynArray[{typ}, 5]
+@external
+def foo(x: {typ}) -> ({typ}, DynArray[{typ}, 5]):
+    temp: DynArray[{typ}, 1] = [x]
+    self.my_array.extend(temp)
+    return self.my_array.pop(), self.my_array
+    """,
+        lambda x: [x, []],
+    ),
+]
+
+
+@pytest.mark.parametrize("code_template,check_result", extend_pop_complex_tests)
+@pytest.mark.parametrize(
+    "subtype", ["uint256[3]", "DynArray[uint256,3]", "DynArray[uint8, 4]", "Foo"]
+)
+# TODO change this to fuzz random data
+def test_extend_pop_complex(get_contract, assert_tx_failed, code_template, check_result, subtype):
+    code = code_template.format(typ=subtype)
+    test_data = [1, 2, 3]
+    if subtype == "Foo":
+        test_data = tuple(test_data)
+        struct_def = """
+struct Foo:
+    x: uint256
+    y: uint256
+    z: uint256
+        """
+        code = struct_def + "\n" + code
+
+    c = get_contract(code)
+    expected_result = check_result(test_data)
+    if expected_result is None:
+        # None is sentinel to indicatecool, I'd txn should revert
+        assert_tx_failed(lambda: c.foo(test_data))
+    else:
+        assert c.foo(test_data) == expected_result
+
+
 def test_so_many_things_you_should_never_do(get_contract):
     code = """
 @internal

vyper/builtin_functions/functions.py

@@ -16,21 +16,26 @@
     IRnode,
     _freshname,
     add_ofst,
+    append_dyn_array,
     bytes_data_ptr,
     calculate_type_for_external_return,
+    check_assign,
     check_external_call,
     clamp,
     clamp2,
     clamp_basetype,
     clamp_nonzero,
     copy_bytes,
+    dummy_node_for_type,
     ensure_in_memory,
     eval_once_check,
     eval_seq,
+    extend_dyn_array,
     get_bytearray_length,
     get_element_ptr,
     ir_tuple_from_args,
     needs_external_call_wrap,
+    pop_dyn_array,
     promote_signed_int,
     shl,
     unwrap_location,
@@ -42,6 +47,7 @@
     BaseType,
     ByteArrayLike,
     ByteArrayType,
+    DArrayType,
     SArrayType,
     StringType,
     TupleType,
@@ -2482,6 +2488,44 @@ def build_IR(self, expr, args, kwargs, context):
             )
 
 
+class Append(BuiltinFunction):
+    _id = "append"
+
+    def build_IR(self, expr, context):
+        darray = Expr(expr.func.value, context).ir_node
+        args = [Expr(x, context).ir_node for x in expr.args]
+
+        # sanity checks
+        assert len(args) == 1
+        arg = args[0]
+        assert isinstance(darray.typ, DArrayType)
+
+        check_assign(dummy_node_for_type(darray.typ.subtype), dummy_node_for_type(arg.typ))
+
+        return append_dyn_array(darray, arg)
+
+
+class Extend(BuiltinFunction):
+    _id = "extend"
+
+    def build_IR(self, expr, context):
+        dst_darray = Expr(expr.func.value, context).ir_node
+        # sanity checks
+        assert len(expr.args) == 1
+        src_darray = Expr(expr.args[0], context).ir_node
+        return extend_dyn_array(context, dst_darray, src_darray)
+
+
+class Pop(BuiltinFunction):
+    _id = "pop"
+
+    def build_IR(self, expr, context, return_popped_item):
+        darray = Expr(expr.func.value, context).ir_node
+        assert isinstance(darray.typ, DArrayType)
+        assert len(expr.args) == 0
+        return pop_dyn_array(darray, return_popped_item=return_popped_item)
+
+
 DISPATCH_TABLE = {
     "_abi_encode": ABIEncode(),
     "_abi_decode": ABIDecode(),
@@ -2523,6 +2567,7 @@ def build_IR(self, expr, args, kwargs, context):
     "max": Max(),
     "empty": Empty(),
     "abs": Abs(),
+    "pop": Pop(),
 }
 
 STMT_DISPATCH_TABLE = {
@@ -2536,6 +2581,9 @@ def build_IR(self, expr, args, kwargs, context):
     "create_forwarder_to": CreateForwarderTo(),
     "create_copy_of": CreateCopyOf(),
     "create_from_blueprint": CreateFromBlueprint(),
+    "append": Append(),
+    "pop": Pop(),
+    "extend": Extend(),
 }
 
 BUILTIN_FUNCTIONS = {**STMT_DISPATCH_TABLE, **DISPATCH_TABLE}.keys()