Merge branch 'master' into feat/venom/call_conv_stack_return

Author: harkal

docs/interfaces.rst

@@ -112,6 +112,20 @@ You can define an interface for your contract with the ``implements`` statement:
 
 This imports the defined interface from the vyper file at ``an_interface.vyi`` (or ``an_interface.json`` if using ABI json interface type) and ensures your current contract implements all the necessary external functions. If any interface functions are not included in the contract, it will fail to compile. This is especially useful when developing contracts around well-defined standards such as ERC20.
 
+Multiple ``implements`` statements can be grouped into one:
+
+.. code-block:: vyper
+
+    implements: Foo
+    implements: Bar
+
+    # Equivalent to:
+
+    implements: (
+        Foo,
+        Bar,
+    )
+
 .. note::
 
   Interfaces that implement functions with return values that require an upper bound (e.g. ``Bytes``, ``DynArray``, or ``String``), the upper bound defined in the interface represents the lower bound of the implementation. Assuming a function ``my_func`` returns a value ``String[1]`` in the interface, this would mean for the implementation function of ``my_func`` that the return value must have **at least** length 1. This behavior might change in the future.

tests/functional/syntax/modules/test_implements.py

@@ -1,4 +1,7 @@
+import pytest
+
 from vyper.compiler import compile_code
+from vyper.exceptions import StructureException
 
 
 def test_implements_from_vyi(make_input_bundle):
@@ -49,3 +52,95 @@ def foo():  # implementation
     input_bundle = make_input_bundle({"some_interface.vyi": vyi, "lib1.vy": lib1, "lib2.vy": lib2})
 
     assert compile_code(main, input_bundle=input_bundle) is not None
+
+
+def test_duplicate_implements_in_same_statement_fails(make_input_bundle):
+    vyi = """
+@external
+def foo():
+    ...
+    """
+    main = """
+import some_interface
+
+implements: (
+    some_interface,
+    some_interface,
+)
+
+@external
+def foo():  # implementation
+    pass
+    """
+    input_bundle = make_input_bundle({"some_interface.vyi": vyi})
+
+    with pytest.raises(StructureException) as e:
+        compile_code(main, input_bundle=input_bundle)
+
+    assert e.value._message == "some_interface implemented more than once"
+    assert e.value._hint is None
+
+
+def test_duplicate_implements_in_different_statement_fails(make_input_bundle):
+    vyi = """
+@external
+def foo():
+    ...
+    """
+    main = """
+import some_interface
+
+implements: some_interface
+implements: some_interface
+
+@external
+def foo():  # implementation
+    pass
+    """
+    input_bundle = make_input_bundle({"some_interface.vyi": vyi})
+
+    with pytest.raises(StructureException) as e:
+        compile_code(main, input_bundle=input_bundle)
+
+    assert e.value._message == "some_interface implemented more than once"
+    assert e.value._hint is None
+
+
+def test_duplicate_implements_in_different_statement_with_mixed_syntax_fails(make_input_bundle):
+    some_interface = """
+@external
+def foo():
+    ...
+    """
+    other_interface = """
+@external
+def bar():
+    ...
+    """
+    main = """
+import some_interface
+import other_interface
+
+implements: some_interface
+implements: (
+    other_interface,
+    some_interface,
+)
+
+@external
+def foo():  # implementation
+    pass
+
+@external
+def bar():  # implementation
+    pass
+    """
+    input_bundle = make_input_bundle(
+        {"some_interface.vyi": some_interface, "other_interface.vyi": other_interface}
+    )
+
+    with pytest.raises(StructureException) as e:
+        compile_code(main, input_bundle=input_bundle)
+
+    assert e.value._message == "some_interface implemented more than once"
+    assert e.value._hint is None

tests/functional/syntax/test_interfaces.py

@@ -218,6 +218,23 @@ def protected_view_fn() -> String[100]:
     """,
         InterfaceViolation,
     ),
+    (
+        """
+interface ITestInterface:
+    def foo() -> uint256: view
+
+interface ITestInterface2:
+    def bar() -> uint256: view
+
+implements: (
+    ITestInterface,
+    ITestInterface2,
+)
+
+foo: public(constant(uint256)) = 1
+        """,
+        InterfaceViolation,
+    ),
 ]
 
 
@@ -360,6 +377,45 @@ def foo() -> uint256: view
 def __init__(x: uint256):
     foo = x
     """,
+    """
+interface Foo:
+  def foo() -> uint256: nonpayable
+
+interface Bar:
+  def bar() -> uint256: nonpayable
+
+
+implements: (
+    Foo,
+    Bar,
+)
+
+@external
+def foo() -> uint256:
+    return 0
+
+@external
+def bar() -> uint256:
+    return 0
+    """,
+    # single method can implement multiple interfaces
+    """
+interface Foo:
+  def foo() -> uint256: nonpayable
+
+interface Foo2:
+  def foo() -> uint256: nonpayable
+
+
+implements: (
+    Foo,
+    Foo2,
+)
+
+@external
+def foo() -> uint256:
+    return 0
+    """,
     # no namespace collision of interface after storage variable
     """
 a: constant(uint256) = 1
@@ -502,6 +558,108 @@ def baz():
     assert compiler.compile_code(code, input_bundle=input_bundle) is not None
 
 
+def test_interfaces_in_different_files_check(make_input_bundle):
+    foo = """
+def foo() -> uint256: ...
+    """
+    bar = """
+def bar() -> uint256: ...
+    """
+
+    input_bundle = make_input_bundle({"foo.vyi": foo, "bar.vyi": bar})
+
+    code = """
+import foo as Foo
+import bar as Bar
+
+implements: (
+    Foo,
+    Bar,
+)
+
+@external
+def foo() -> uint256:
+    return 0
+
+@external
+def bar() -> uint256:
+    return 0
+    """
+
+    res = compiler.compile_code(code, input_bundle=input_bundle)
+
+    assert res is not None
+
+
+def test_implements_in_interface_file_check(make_input_bundle):
+    foo = """
+def foo() -> uint256: ...
+    """
+    bar = """
+def bar() -> uint256: ...
+    """
+    qux = """
+from interfaces import foo as Foo, bar as Bar
+
+implements: (
+    Foo,
+    Bar,
+)
+
+def foo() -> uint256: ...
+def bar() -> uint256: ...
+def qux() -> uint256: ...
+    """
+
+    input_bundle = make_input_bundle(
+        {"interfaces/foo.vyi": foo, "interfaces/bar.vyi": bar, "interfaces/qux.vyi": qux}
+    )
+
+    code = """
+from interfaces import qux as Qux
+
+implements: (
+    Qux,
+)
+
+@external
+def foo() -> uint256:
+    return 0
+
+@external
+def bar() -> uint256:
+    return 0
+
+@external
+def qux() -> uint256:
+    return 0
+    """
+
+    res = compiler.compile_code(code, input_bundle=input_bundle)
+
+    assert res is not None
+
+
+def test_interface_file_type_check(make_input_bundle):
+    interface_code = """
+"""
+
+    input_bundle = make_input_bundle({"foo.vy": interface_code})
+
+    code = """
+import foo as Foo
+
+implements: Foo
+"""
+    with pytest.raises(StructureException) as e:
+        compiler.compile_code(code, input_bundle=input_bundle)
+
+    assert (
+        e.value._message == "Not an interface!"
+        " (Since vyper v0.4.0, interface files are required to have a .vyi suffix.)"
+    )
+
+
 invalid_visibility_code = [
     """
 import foo as Foo

tests/unit/ast/test_ast_dict.py

@@ -99,16 +99,18 @@ def foo() -> uint256:
     dict_out = compiler.compile_code(code, output_formats=["ast_dict"], source_id=0)
     assert dict_out["ast_dict"]["ast"]["body"][1] == {
         "col_offset": 0,
-        "annotation": {
-            "col_offset": 12,
-            "end_col_offset": 15,
-            "node_id": 12,
-            "src": "60:3:0",
-            "ast_type": "Name",
-            "end_lineno": 5,
-            "lineno": 5,
-            "id": "Foo",
-        },
+        "children": [
+            {
+                "col_offset": 12,
+                "end_col_offset": 15,
+                "node_id": 12,
+                "src": "60:3:0",
+                "ast_type": "Name",
+                "end_lineno": 5,
+                "lineno": 5,
+                "id": "Foo",
+            }
+        ],
         "end_col_offset": 15,
         "node_id": 9,
         "src": "48:15:0",