feat[ux]: compile .vyi files

tests/functional/codegen/test_interfaces.py

@@ -774,3 +774,39 @@ def foo(s: MyStruct) -> MyStruct:
     assert "b: uint256" in out
     assert "struct Voter:" in out
     assert "voted: bool" in out
+
+
+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

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
 from vyper.compiler.input_bundle import FilesystemInputBundle
 from vyper.compiler.output_bundle import OutputBundle
 from vyper.compiler.phases import CompilerData
@@ -425,3 +426,56 @@ 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)
+
+    unallowed_formats = [
+        "layout",
+        "devdoc",
+        "userdoc",
+        "archive",
+        "archive_b64",
+        "integrity",
+        "solc_json",
+        "bb",
+        "bb_runtime",
+        "cfg",
+        "cfg_runtime",
+        "ir",
+        "ir_runtime",
+        "ir_dict",
+        "ir_runtime_dict",
+        "method_identifiers",
+        "metadata",
+        "asm",
+        "source_map",
+        "source_map_runtime",
+        "bytecode",
+        "bytecode_runtime",
+        "blueprint_bytecode",
+        "opcodes",
+        "opcodes_runtime",
+    ]
+
+    for f in unallowed_formats:
+        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,6 +23,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.
@@ -84,6 +85,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_parse_result.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>"
 
@@ -117,10 +124,18 @@ def compile_from_file_input(
     )
 
     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 = 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

@@ -110,7 +110,7 @@ def build_external_interface_output(compiler_data: CompilerData) -> str:
     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 = "".join([x[0].upper() + x[1:] for x in stem.split("_")])
     out = f"\n# External Interfaces\ninterface {name}:\n"
 
     for func in interface.functions.values():
@@ -136,6 +136,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():
@@ -265,7 +273,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 compiler_data.show_gas_estimates:

vyper/compiler/phases.py

@@ -112,11 +112,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):