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

@@ -20,7 +20,7 @@
 from vyper.semantics.analysis.base import ExprInfo, Modifiability, ModuleInfo, VarInfo
 from vyper.semantics.analysis.levenshtein_utils import get_levenshtein_error_suggestions
 from vyper.semantics.namespace import get_namespace
-from vyper.semantics.types.base import TYPE_T, VyperType
+from vyper.semantics.types.base import TYPE_T, VyperType, is_type_t
 from vyper.semantics.types.bytestrings import BytesT, StringT
 from vyper.semantics.types.primitives import AddressT, BoolT, BytesM_T, IntegerT
 from vyper.semantics.types.subscriptable import DArrayT, SArrayT, TupleT
@@ -646,10 +646,20 @@ def check_modifiability(node: vy_ast.VyperNode, modifiability: Modifiability) ->
 
     if isinstance(node, vy_ast.Call):
         args = node.args
+
+        # structs
         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)
+
+        # interfaces
+        from vyper.semantics.types.module import InterfaceT
+
+        if is_type_t(call_type, InterfaceT):
+            return check_modifiability(args[0], modifiability)
+
+        # builtins
         call_type_modifiability = getattr(call_type, "_modifiability", Modifiability.MODIFIABLE)
         return call_type_modifiability >= modifiability