feat: allow constant interfaces

tests/functional/codegen/calling_convention/test_default_parameters.py

@@ -111,6 +111,41 @@ def fooBar(a: Bytes[100], b: uint256[2], c: Bytes[6] = b"hello", d: int128[3] =
     assert c.fooBar(b"booo", [55, 66]) == [b"booo", 66, c_default, d_default]
 
 
+def test_default_param_interface(get_contract):
+    code = """
+interface Foo:
+    def bar(): payable
+
+FOO: constant(Foo) = Foo(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF)
+
+@external
+def bar(a: uint256, b: Foo = Foo(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF)) -> Foo:
+    return b
+
+@external
+def baz(a: uint256, b: Foo = Foo(empty(address))) -> Foo:
+    return b
+
+@external
+def faz(a: uint256, b: Foo = FOO) -> Foo:
+    return b
+    """
+    c = get_contract(code)
+
+    assert c.bar(1) == "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
+    assert (
+        c.bar(1, "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
+        == "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
+    )
+    assert c.baz(1) is None
+    assert c.baz(1, "0x0000000000000000000000000000000000000000") is None
+    assert c.faz(1) == "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
+    assert (
+        c.faz(1, "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF")
+        == "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
+    )
+
+
 def test_default_param_internal_function(get_contract):
     code = """
 @internal

tests/functional/codegen/storage_variables/test_getters.py

@@ -19,6 +19,9 @@ def foo() -> int128:
 
 def test_getter_code(get_contract_with_gas_estimation_for_constants):
     getter_code = """
+interface V:
+    def foo(): nonpayable
+
 struct W:
     a: uint256
     b: int128[7]
@@ -36,6 +39,7 @@ def test_getter_code(get_contract_with_gas_estimation_for_constants):
 d: public(immutable(uint256))
 e: public(immutable(uint256[2]))
 f: public(constant(uint256[2])) = [3, 7]
+g: public(constant(V)) = V(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF)
 
 @external
 def __init__():
@@ -70,6 +74,7 @@ def __init__():
     assert c.d() == 1729
     assert c.e(0) == 2
     assert [c.f(i) for i in range(2)] == [3, 7]
+    assert c.g() == "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF"
 
 
 def test_getter_mutability(get_contract):

tests/functional/syntax/test_constants.py

@@ -304,6 +304,19 @@ def deposit(deposit_input: Bytes[2048]):
 
 CONST_BAR: constant(Bar) = Bar({c: C, d: D})
     """,
+    """
+interface Foo:
+    def foo(): nonpayable
+
+FOO: constant(Foo) = Foo(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF)
+    """,
+    """
+interface Foo:
+    def foo(): nonpayable
+
+FOO: constant(Foo) = Foo(BAR)
+BAR: constant(address) = 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF
+    """,
 ]
 
 

vyper/codegen/expr.py

@@ -190,9 +190,9 @@ def parse_Name(self):
             varinfo = self.context.globals[self.expr.id]
 
             if varinfo.is_constant:
-                # non-struct constants should have already gotten propagated
-                # during constant folding
-                assert isinstance(varinfo.typ, StructT)
+                # constants other than structs and interfaces should have already gotten
+                # propagated during constant folding
+                assert isinstance(varinfo.typ, (InterfaceT, StructT))
                 return Expr.parse_value_expr(varinfo.decl_node.value, self.context)
 
             assert varinfo.is_immutable, "not an immutable!"

vyper/semantics/analysis/utils.py

@@ -645,11 +645,16 @@ def check_modifiability(node: vy_ast.VyperNode, modifiability: Modifiability) ->
         return all(check_modifiability(item, modifiability) for item in node.elements)
 
     if isinstance(node, vy_ast.Call):
-        args = node.args
-        if len(args) == 1 and isinstance(args[0], vy_ast.Dict):
-            return all(check_modifiability(v, modifiability) for v in args[0].values)
-
         call_type = get_exact_type_from_node(node.func)
+
+        # structs and interfaces
+        if isinstance(call_type, TYPE_T):
+            call_type = call_type.typedef
+
+        if hasattr(call_type, "check_modifiability_for_call"):
+            return call_type.check_modifiability_for_call(node, modifiability)
+
+        # builtins
         call_type_modifiability = getattr(call_type, "_modifiability", Modifiability.MODIFIABLE)
         return call_type_modifiability >= modifiability
 

vyper/semantics/types/module.py

@@ -5,8 +5,12 @@
 from vyper.abi_types import ABI_Address, ABIType
 from vyper.ast.validation import validate_call_args
 from vyper.exceptions import InterfaceViolation, NamespaceCollision, StructureException
-from vyper.semantics.analysis.base import VarInfo
-from vyper.semantics.analysis.utils import validate_expected_type, validate_unique_method_ids
+from vyper.semantics.analysis.base import Modifiability, VarInfo
+from vyper.semantics.analysis.utils import (
+    check_modifiability,
+    validate_expected_type,
+    validate_unique_method_ids,
+)
 from vyper.semantics.namespace import get_namespace
 from vyper.semantics.types.base import TYPE_T, VyperType
 from vyper.semantics.types.function import ContractFunctionT
@@ -66,6 +70,9 @@
     def _ctor_kwarg_types(self, node):
         return {}
 
+    def check_modifiability_for_call(self, node: vy_ast.Call, modifiability: Modifiability) -> bool:
+        return check_modifiability(node.args[0], modifiability)
+
     # TODO x.validate_implements(other)
     def validate_implements(self, node: vy_ast.ImplementsDecl) -> None:
         namespace = get_namespace()

vyper/semantics/types/user.py

@@ -13,8 +13,9 @@
     UnknownAttribute,
     VariableDeclarationException,
 )
+from vyper.semantics.analysis.base import Modifiability
 from vyper.semantics.analysis.levenshtein_utils import get_levenshtein_error_suggestions
-from vyper.semantics.analysis.utils import validate_expected_type
+from vyper.semantics.analysis.utils import check_modifiability, validate_expected_type
 from vyper.semantics.data_locations import DataLocation
 from vyper.semantics.types.base import VyperType
 from vyper.semantics.types.subscriptable import HashMapT
@@ -408,3 +409,6 @@
             )
 
         return self
+
+    def check_modifiability_for_call(self, node: vy_ast.Call, modifiability: Modifiability) -> bool:
+        return all(check_modifiability(v, modifiability) for v in node.args[0].values)