feat[ux]: allow "compiling" .vyi files

tests/functional/codegen/test_interfaces.py

@@ -876,3 +876,108 @@ def bar() -> uint256:
     input_bundle = make_input_bundle({"lib1.vy": lib1})
     c = get_contract(main, input_bundle=input_bundle)
     assert c.bar() == 1
+
+
+def test_interface_with_flags():
+    code = """
+struct MyStruct:
+    a: address
+
+flag Foo:
+    BOO
+    MOO
+    POO
+
+event Transfer:
+    sender: indexed(address)
+
+@external
+def bar():
+    pass
+flag BAR:
+    BIZ
+    BAZ
+    BOO
+
+@external
+@view
+def foo(s: MyStruct) -> MyStruct:
+    return s
+    """
+
+    out = compile_code(code, contract_path="code.vy", output_formats=["interface"])["interface"]
+
+    assert "# Flags" in out
+    assert "flag Foo:" in out
+    assert "flag BAR" in out
+    assert "BOO" in out
+    assert "MOO" in out
+
+    compile_code(out, contract_path="code.vyi", output_formats=["interface"])
+
+
+vyi_filenames = [
+    "test__test.vyi",
+    "test__t.vyi",
+    "t__test.vyi",
+    "t__t.vyi",
+    "t_t.vyi",
+    "test_test.vyi",
+    "t_test.vyi",
+    "test_t.vyi",
+    "_test_t__t_tt_.vyi",
+    "foo_bar_baz.vyi",
+]
+
+
+@pytest.mark.parametrize("vyi_filename", vyi_filenames)
+def test_external_interface_names(vyi_filename):
+    code = """
+@external
+def foo():
+    ...
+    """
+
+    compile_code(code, contract_path=vyi_filename, output_formats=["external_interface"])
+
+
+def test_external_interface_with_flag():
+    code = """
+flag Foo:
+    Blah
+
+@external
+def foo() -> Foo:
+    ...
+    """
+
+    out = compile_code(code, contract_path="test__test.vyi", output_formats=["external_interface"])[
+        "external_interface"
+    ]
+    assert "-> Foo:" in out
+
+
+def test_external_interface_compiles_again():
+    code = """
+@external
+def foo() -> uint256:
+    ...
+@external
+def bar(a:int32) -> uint256:
+    ...
+    """
+
+    out = compile_code(code, contract_path="test.vyi", output_formats=["external_interface"])[
+        "external_interface"
+    ]
+    compile_code(out, contract_path="test.vyi", output_formats=["external_interface"])
+
+
+@pytest.mark.xfail
+def test_weird_interface_name():
+    # based on comment https://github.com/vyperlang/vyper/pull/4290#discussion_r1884137428
+    # we replace "_" for "" which results in an interface without name
+    out = compile_code("", contract_path="_.vyi", output_formats=["external_interface"])[
+        "external_interface"
+    ]
+    assert "interface _:" in out

tests/unit/ast/test_ast_dict.py

@@ -399,6 +399,7 @@ def foo():
         "node_id": 0,
         "path": "main.vy",
         "source_id": 1,
+        "is_interface": False,
         "type": {
             "name": "main.vy",
             "type_decl_node": {"node_id": 0, "source_id": 1},
@@ -1175,6 +1176,7 @@ def foo():
         "node_id": 0,
         "path": "lib1.vy",
         "source_id": 0,
+        "is_interface": False,
         "type": {
             "name": "lib1.vy",
             "type_decl_node": {"node_id": 0, "source_id": 0},

tests/unit/cli/vyper_compile/test_compile_files.py

@@ -7,6 +7,7 @@
 
 from vyper.cli.vyper_compile import compile_files
 from vyper.cli.vyper_json import compile_json
+from vyper.compiler import INTERFACE_OUTPUT_FORMATS, OUTPUT_FORMATS
 from vyper.compiler.input_bundle import FilesystemInputBundle
 from vyper.compiler.output_bundle import OutputBundle
 from vyper.compiler.phases import CompilerData
@@ -425,3 +426,31 @@ def test_archive_search_path(tmp_path_factory, make_file, chdir_tmp_path):
 
         used_dir = search_paths[-1].stem  # either dir1 or dir2
         assert output_bundle.used_search_paths == [".", "0/" + used_dir]
+
+
+def test_compile_interface_file(make_file):
+    interface = """
+@view
+@external
+def foo() -> String[1]:
+    ...
+
+@view
+@external
+def bar() -> String[1]:
+    ...
+
+@external
+def baz() -> uint8:
+    ...
+
+    """
+    file = make_file("interface.vyi", interface)
+    compile_files([file], INTERFACE_OUTPUT_FORMATS)
+
+    # check unallowed output formats
+    for f in OUTPUT_FORMATS:
+        if f in INTERFACE_OUTPUT_FORMATS:
+            continue
+        with pytest.raises(ValueError):
+            compile_files([file], [f])

vyper/ast/nodes.py

@@ -638,7 +638,7 @@ class TopLevel(VyperNode):
 
 class Module(TopLevel):
     # metadata
-    __slots__ = ("path", "resolved_path", "source_id")
+    __slots__ = ("path", "resolved_path", "source_id", "is_interface")
 
     def to_dict(self):
         return dict(source_sha256sum=self.source_sha256sum, **super().to_dict())

vyper/ast/nodes.pyi

@@ -71,6 +71,7 @@ class Module(TopLevel):
     path: str = ...
     resolved_path: str = ...
     source_id: int = ...
+    is_interface: bool = ...
     def namespace(self) -> Any: ...  # context manager
 
 class FunctionDef(TopLevel):

vyper/ast/parse.py

@@ -23,10 +23,11 @@ def parse_to_ast_with_settings(
     module_path: Optional[str] = None,
     resolved_path: Optional[str] = None,
     add_fn_node: Optional[str] = None,
+    is_interface: bool = False,
 ) -> tuple[Settings, vy_ast.Module]:
     try:
         return _parse_to_ast_with_settings(
-            vyper_source, source_id, module_path, resolved_path, add_fn_node
+            vyper_source, source_id, module_path, resolved_path, add_fn_node, is_interface
         )
     except SyntaxException as e:
         e.resolved_path = resolved_path
@@ -39,6 +40,7 @@ def _parse_to_ast_with_settings(
     module_path: Optional[str] = None,
     resolved_path: Optional[str] = None,
     add_fn_node: Optional[str] = None,
+    is_interface: bool = False,
 ) -> tuple[Settings, vy_ast.Module]:
     """
     Parses a Vyper source string and generates basic Vyper AST nodes.
@@ -62,6 +64,9 @@ def _parse_to_ast_with_settings(
     resolved_path: str, optional
         The resolved path of the source code
         Corresponds to FileInput.resolved_path
+    is_interface: bool
+        Indicates whether the source code should
+        be parsed as an interface file.
 
     Returns
     -------
@@ -106,6 +111,7 @@ def _parse_to_ast_with_settings(
     # Convert to Vyper AST.
     module = vy_ast.get_node(py_ast)
     assert isinstance(module, vy_ast.Module)  # mypy hint
+    module.is_interface = is_interface
 
     return pre_parser.settings, module
 

vyper/compiler/__init__.py

@@ -46,6 +46,13 @@
     "opcodes_runtime": output.build_opcodes_runtime_output,
 }
 
+INTERFACE_OUTPUT_FORMATS = [
+    "ast_dict",
+    "annotated_ast_dict",
+    "interface",
+    "external_interface",
+    "abi",
+]
 
 UNKNOWN_CONTRACT_NAME = "<unknown>"
 
@@ -121,10 +128,18 @@ def outputs_from_compiler_data(
         output_formats = ("bytecode",)
 
     ret = {}
+
     with anchor_settings(compiler_data.settings):
         for output_format in output_formats:
             if output_format not in OUTPUT_FORMATS:
                 raise ValueError(f"Unsupported format type {repr(output_format)}")
+
+            is_vyi = compiler_data.file_input.resolved_path.suffix == ".vyi"
+            if is_vyi and output_format not in INTERFACE_OUTPUT_FORMATS:
+                raise ValueError(
+                    f"Unsupported format for compiling interface: {repr(output_format)}"
+                )
+
             try:
                 formatter = OUTPUT_FORMATS[output_format]
                 ret[output_format] = formatter(compiler_data)

vyper/compiler/output.py

@@ -108,9 +108,8 @@ def build_integrity(compiler_data: CompilerData) -> str:
 def build_external_interface_output(compiler_data: CompilerData) -> str:
     interface = compiler_data.annotated_vyper_module._metadata["type"].interface
     stem = PurePath(compiler_data.contract_path).stem
-    # capitalize words separated by '_'
-    # ex: test_interface.vy -> TestInterface
-    name = "".join([x.capitalize() for x in stem.split("_")])
+
+    name = stem.title().replace("_", "")
     out = f"\n# External Interfaces\ninterface {name}:\n"
 
     for func in interface.functions.values():
@@ -136,6 +135,14 @@ def build_interface_output(compiler_data: CompilerData) -> str:
                 out += f"    {member_name}: {member_type}\n"
             out += "\n\n"
 
+    if len(interface.flags) > 0:
+        out += "# Flags\n\n"
+        for flag in interface.flags.values():
+            out += f"flag {flag.name}:\n"
+            for flag_value in flag._flag_members:
+                out += f"    {flag_value}\n"
+            out += "\n\n"
+
     if len(interface.events) > 0:
         out += "# Events\n\n"
         for event in interface.events.values():
@@ -282,7 +289,8 @@ def build_method_identifiers_output(compiler_data: CompilerData) -> dict:
 
 def build_abi_output(compiler_data: CompilerData) -> list:
     module_t = compiler_data.annotated_vyper_module._metadata["type"]
-    _ = compiler_data.ir_runtime  # ensure _ir_info is generated
+    if not compiler_data.annotated_vyper_module.is_interface:
+        _ = compiler_data.ir_runtime  # ensure _ir_info is generated
 
     abi = module_t.interface.to_toplevel_abi_dict()
     if module_t.init_function:

vyper/compiler/phases.py

@@ -113,11 +113,14 @@ def contract_path(self):
 
     @cached_property
     def _generate_ast(self):
+        is_vyi = self.contract_path.suffix == ".vyi"
+
         settings, ast = vy_ast.parse_to_ast_with_settings(
             self.source_code,
             self.source_id,
             module_path=self.contract_path.as_posix(),
             resolved_path=self.file_input.resolved_path.as_posix(),
+            is_interface=is_vyi,
         )
 
         if self.original_settings:

vyper/semantics/analysis/module.py

@@ -53,7 +53,7 @@ def analyze_module(module_ast: vy_ast.Module) -> ModuleT:
     add all module-level objects to the namespace, type-check/validate
     semantics and annotate with type and analysis info
     """
-    return _analyze_module_r(module_ast)
+    return _analyze_module_r(module_ast, module_ast.is_interface)
 
 
 def _analyze_module_r(module_ast: vy_ast.Module, is_interface: bool = False):

vyper/semantics/types/user.py

@@ -77,6 +77,9 @@ def get_type_member(self, key: str, node: vy_ast.VyperNode) -> "VyperType":
         self._helper.get_member(key, node)
         return self
 
+    def __str__(self):
+        return f"{self.name}"
+
     def __repr__(self):
         arg_types = ",".join(repr(a) for a in self._flag_members)
         return f"flag {self.name}({arg_types})"