feat[lang]: add module.__at__() to cast to interface

tests/functional/codegen/modules/test_exports.py

@@ -440,3 +440,26 @@ def __init__():
     # call `c.__default__()`
     env.message_call(c.address)
     assert c.counter() == 6
+
+
+def test_inline_interface_export(make_input_bundle, get_contract):
+    lib1 = """
+interface IAsset:
+    def asset() -> address: view
+
+implements: IAsset
+
+@external
+@view
+def asset() -> address:
+    return self
+    """
+    main = """
+import lib1
+
+exports: lib1.IAsset
+    """
+    input_bundle = make_input_bundle({"lib1.vy": lib1})
+    c = get_contract(main, input_bundle=input_bundle)
+
+    assert c.asset() == c.address

tests/functional/codegen/modules/test_interface_imports.py

@@ -50,16 +50,45 @@ def foo() -> bool:
     # check that this typechecks both directions
     a: lib1.IERC20 = IERC20(msg.sender)
     b: lib2.IERC20 = IERC20(msg.sender)
+    c: IERC20 = lib1.IERC20(msg.sender)  # allowed in call position
 
     # return the equality so we can sanity check it
-    return a == b
+    return a == b and b == c
     """
     input_bundle = make_input_bundle({"lib1.vy": lib1, "lib2.vy": lib2})
     c = get_contract(main, input_bundle=input_bundle)
 
     assert c.foo() is True
 
 
+def test_intrinsic_interface(get_contract, make_input_bundle):
+    lib = """
+@external
+@view
+def foo() -> uint256:
+    # detect self call
+    if msg.sender == self:
+        return 4
+    else:
+        return 5
+    """
+    main = """
+import lib
+
+exports: lib.__interface__
+
+@external
+@view
+def bar() -> uint256:
+    return staticcall lib.__interface__(self).foo()
+    """
+    input_bundle = make_input_bundle({"lib.vy": lib})
+    c = get_contract(main, input_bundle=input_bundle)
+
+    assert c.foo() == 5
+    assert c.bar() == 4
+
+
 def test_import_interface_flags(make_input_bundle, get_contract):
     ifaces = """
 flag Foo:

tests/functional/syntax/modules/test_deploy_visibility.py

@@ -1,7 +1,7 @@
 import pytest
 
 from vyper.compiler import compile_code
-from vyper.exceptions import CallViolation
+from vyper.exceptions import CallViolation, UnknownAttribute
 
 
 def test_call_deploy_from_external(make_input_bundle):
@@ -25,3 +25,34 @@ def foo():
         compile_code(main, input_bundle=input_bundle)
 
     assert e.value.message == "Cannot call an @deploy function from an @external function!"
+
+
+def test_module_interface_init(make_input_bundle, tmp_path):
+    lib1 = """
+#lib1.vy
+k: uint256
+
+@external
+def bar():
+    pass
+
+@deploy
+def __init__():
+    self.k = 10
+    """
+    input_bundle = make_input_bundle({"lib1.vy": lib1})
+
+    code = """
+import lib1
+
+@deploy
+def __init__():
+    lib1.__interface__(self).__init__()
+    """
+
+    with pytest.raises(UnknownAttribute) as e:
+        compile_code(code, input_bundle=input_bundle)
+
+    # as_posix() for windows tests
+    lib1_path = (tmp_path / "lib1.vy").as_posix()
+    assert e.value.message == f"interface {lib1_path} has no member '__init__'."

tests/functional/syntax/modules/test_exports.py

@@ -385,6 +385,28 @@ def do_xyz():
     assert e.value._message == "requested `lib1.ifoo` but `lib1` does not implement `lib1.ifoo`!"
 
 
+def test_no_export_unimplemented_inline_interface(make_input_bundle):
+    lib1 = """
+interface ifoo:
+    def do_xyz(): nonpayable
+
+# technically implements ifoo, but missing `implements: ifoo`
+
+@external
+def do_xyz():
+    pass
+    """
+    main = """
+import lib1
+
+exports: lib1.ifoo
+    """
+    input_bundle = make_input_bundle({"lib1.vy": lib1})
+    with pytest.raises(InterfaceViolation) as e:
+        compile_code(main, input_bundle=input_bundle)
+    assert e.value._message == "requested `lib1.ifoo` but `lib1` does not implement `lib1.ifoo`!"
+
+
 def test_export_selector_conflict(make_input_bundle):
     ifoo = """
 @external
@@ -444,3 +466,55 @@ def __init__():
     with pytest.raises(InterfaceViolation) as e:
         compile_code(main, input_bundle=input_bundle)
     assert e.value._message == "requested `lib1.ifoo` but `lib1` does not implement `lib1.ifoo`!"
+
+
+def test_export_empty_interface(make_input_bundle, tmp_path):
+    lib1 = """
+def an_internal_function():
+    pass
+    """
+    main = """
+import lib1
+
+exports: lib1.__interface__
+    """
+    input_bundle = make_input_bundle({"lib1.vy": lib1})
+    with pytest.raises(StructureException) as e:
+        compile_code(main, input_bundle=input_bundle)
+
+    # as_posix() for windows
+    lib1_path = (tmp_path / "lib1.vy").as_posix()
+    assert e.value._message == f"lib1 (located at `{lib1_path}`) has no external functions!"
+
+
+def test_invalid_export(make_input_bundle):
+    lib1 = """
+@external
+def foo():
+    pass
+    """
+    main = """
+import lib1
+a: address
+
+exports: lib1.__interface__(self.a).foo
+    """
+    input_bundle = make_input_bundle({"lib1.vy": lib1})
+
+    with pytest.raises(StructureException) as e:
+        compile_code(main, input_bundle=input_bundle)
+
+    assert e.value._message == "invalid export of a value"
+    assert e.value._hint == "exports should look like <module>.<function | interface>"
+
+    main = """
+interface Foo:
+    def foo(): nonpayable
+
+exports: Foo
+    """
+    with pytest.raises(StructureException) as e:
+        compile_code(main)
+
+    assert e.value._message == "invalid export"
+    assert e.value._hint == "exports should look like <module>.<function | interface>"

vyper/codegen/expr.py

@@ -51,6 +51,7 @@
     FlagT,
     HashMapT,
     InterfaceT,
+    ModuleT,
     SArrayT,
     StringT,
     StructT,
@@ -680,7 +681,8 @@ def parse_Call(self):
         # TODO fix cyclic import
         from vyper.builtins._signatures import BuiltinFunctionT
 
-        func_t = self.expr.func._metadata["type"]
+        func = self.expr.func
+        func_t = func._metadata["type"]
 
         if isinstance(func_t, BuiltinFunctionT):
             return func_t.build_IR(self.expr, self.context)
@@ -691,8 +693,14 @@ def parse_Call(self):
             return self.handle_struct_literal()
 
         # Interface constructor. Bar(<address>).
-        if is_type_t(func_t, InterfaceT):
+        if is_type_t(func_t, InterfaceT) or func.get("attr") == "__at__":
             assert not self.is_stmt  # sanity check typechecker
+
+            # magic: do sanity checks for module.__at__
+            if func.get("attr") == "__at__":
+                assert isinstance(func_t, MemberFunctionT)
+                assert isinstance(func.value._metadata["type"], ModuleT)
+
             (arg0,) = self.expr.args
             arg_ir = Expr(arg0, self.context).ir_node
 
@@ -702,16 +710,16 @@ def parse_Call(self):
             return arg_ir
 
         if isinstance(func_t, MemberFunctionT):
-            darray = Expr(self.expr.func.value, self.context).ir_node
+            # TODO consider moving these to builtins or a dedicated file
+            darray = Expr(func.value, self.context).ir_node
             assert isinstance(darray.typ, DArrayT)
             args = [Expr(x, self.context).ir_node for x in self.expr.args]
-            if self.expr.func.attr == "pop":
-                # TODO consider moving this to builtins
-                darray = Expr(self.expr.func.value, self.context).ir_node
+            if func.attr == "pop":
+                darray = Expr(func.value, self.context).ir_node
                 assert len(self.expr.args) == 0
                 return_item = not self.is_stmt
                 return pop_dyn_array(darray, return_popped_item=return_item)
-            elif self.expr.func.attr == "append":
+            elif func.attr == "append":
                 (arg,) = args
                 check_assign(
                     dummy_node_for_type(darray.typ.value_type), dummy_node_for_type(arg.typ)
@@ -726,6 +734,8 @@ def parse_Call(self):
                 ret.append(append_dyn_array(darray, arg))
                 return IRnode.from_list(ret)
 
+            raise CompilerPanic("unreachable!")  # pragma: nocover
+
         assert isinstance(func_t, ContractFunctionT)
         assert func_t.is_internal or func_t.is_constructor
 

vyper/compiler/output.py

@@ -268,6 +268,9 @@ def build_abi_output(compiler_data: CompilerData) -> list:
     _ = compiler_data.ir_runtime  # ensure _ir_info is generated
 
     abi = module_t.interface.to_toplevel_abi_dict()
+    if module_t.init_function:
+        abi += module_t.init_function.to_toplevel_abi_dict()
+
     if compiler_data.show_gas_estimates:
         # Add gas estimates for each function to ABI
         gas_estimates = build_gas_estimates(compiler_data.function_signatures)

vyper/semantics/analysis/base.py

@@ -13,7 +13,7 @@
 
 if TYPE_CHECKING:
     from vyper.semantics.types.function import ContractFunctionT
     from vyper.semantics.types.module import ModuleT
 
 
 class FunctionVisibility(StringEnum):
@@ -96,6 +96,7 @@
 class ModuleInfo(AnalysisResult):
     module_t: "ModuleT"
     alias: str
+    # import_node: vy_ast._ImportStmt # maybe could be useful
     ownership: ModuleOwnership = ModuleOwnership.NO_OWNERSHIP
     ownership_decl: Optional[vy_ast.VyperNode] = None
 

vyper/semantics/analysis/module.py

@@ -40,7 +40,7 @@
 )
 from vyper.semantics.data_locations import DataLocation
 from vyper.semantics.namespace import Namespace, get_namespace, override_global_namespace
-from vyper.semantics.types import EventT, FlagT, InterfaceT, StructT
+from vyper.semantics.types import TYPE_T, EventT, FlagT, InterfaceT, StructT, is_type_t
 from vyper.semantics.types.function import ContractFunctionT
 from vyper.semantics.types.module import ModuleT
 from vyper.semantics.types.utils import type_from_annotation
@@ -499,9 +499,19 @@ def visit_ExportsDecl(self, node):
                     raise StructureException("not a public variable!", decl, item)
                 funcs = [decl._expanded_getter._metadata["func_type"]]
             elif isinstance(info.typ, ContractFunctionT):
+                # e.g. lib1.__interface__(self._addr).foo
+                if not isinstance(get_expr_info(item.value).typ, (ModuleT, TYPE_T)):
+                    raise StructureException(
+                        "invalid export of a value",
+                        item.value,
+                        hint="exports should look like <module>.<function | interface>",
+                    )
+
                 # regular function
                 funcs = [info.typ]
-            elif isinstance(info.typ, InterfaceT):
+            elif is_type_t(info.typ, InterfaceT):
+                interface_t = info.typ.typedef
+
                 if not isinstance(item, vy_ast.Attribute):
                     raise StructureException(
                         "invalid export",
@@ -512,7 +522,7 @@ def visit_ExportsDecl(self, node):
                 if module_info is None:
                     raise StructureException("not a valid module!", item.value)
 
-                if info.typ not in module_info.typ.implemented_interfaces:
+                if interface_t not in module_info.typ.implemented_interfaces:
                     iface_str = item.node_source_code
                     module_str = item.value.node_source_code
                     msg = f"requested `{iface_str}` but `{module_str}`"
@@ -523,9 +533,15 @@ def visit_ExportsDecl(self, node):
                 # find the specific implementation of the function in the module
                 funcs = [
                     module_exposed_fns[fn.name]
-                    for fn in info.typ.functions.values()
+                    for fn in interface_t.functions.values()
                     if fn.is_external
                 ]
+
+                if len(funcs) == 0:
+                    path = module_info.module_node.path
+                    msg = f"{module_info.alias} (located at `{path}`) has no external functions!"
+                    raise StructureException(msg, item)
+
             else:
                 raise StructureException(
                     f"not a function or interface: `{info.typ}`", info.typ.decl_node, item

vyper/semantics/analysis/utils.py

@@ -199,7 +199,7 @@ def _raise_invalid_reference(name, node):
         try:
             s = t.get_member(name, node)
 
-            if isinstance(s, (VyperType, TYPE_T)):
+            if isinstance(s, VyperType):
                 # ex. foo.bar(). bar() is a ContractFunctionT
                 return [s]
 

vyper/semantics/types/__init__.py

@@ -1,8 +1,8 @@
 from . import primitives, subscriptable, user
 from .base import TYPE_T, VOID_TYPE, KwargSettings, VyperType, is_type_t, map_void
 from .bytestrings import BytesT, StringT, _BytestringT
-from .function import MemberFunctionT
-from .module import InterfaceT
+from .function import ContractFunctionT, MemberFunctionT
+from .module import InterfaceT, ModuleT
 from .primitives import AddressT, BoolT, BytesM_T, DecimalT, IntegerT, SelfT
 from .subscriptable import DArrayT, HashMapT, SArrayT, TupleT
 from .user import EventT, FlagT, StructT

vyper/semantics/types/base.py

@@ -114,8 +114,13 @@ def __eq__(self, other):
         )
 
     def __lt__(self, other):
+        # CMC 2024-10-20 what is this for?
         return self.abi_type.selector_name() < other.abi_type.selector_name()
 
+    def __repr__(self):
+        # TODO: add `pretty()` to the VyperType API?
+        return self._id
+
     # return a dict suitable for serializing in the AST
     def to_dict(self):
         ret = {"name": self._id}
@@ -362,10 +367,7 @@ def get_member(self, key: str, node: vy_ast.VyperNode) -> "VyperType":
             raise StructureException(f"{self} instance does not have members", node)
 
         hint = get_levenshtein_error_suggestions(key, self.members, 0.3)
-        raise UnknownAttribute(f"{self} has no member '{key}'.", node, hint=hint)
-
-    def __repr__(self):
-        return self._id
+        raise UnknownAttribute(f"{repr(self)} has no member '{key}'.", node, hint=hint)
 
 
 class KwargSettings:

vyper/semantics/types/function.py

@@ -874,7 +874,7 @@ def _id(self):
         return self.name
 
     def __repr__(self):
-        return f"{self.underlying_type._id} member function '{self.name}'"
+        return f"{self.underlying_type} member function '{self.name}'"
 
     def fetch_call_return(self, node: vy_ast.Call) -> Optional[VyperType]:
         validate_call_args(node, len(self.arg_types))