feat[tool]: add venom artifacts into solc_json output (#4637)

this commit adds venom output keys `bb/bb_runtime` and
`cfg/cfg_runtime` into the output artifact when calling
`compile_json()`, adding extra information for downstream tooling to
display.

---------

Co-authored-by: Charles Cooper <cooper.charles.m@gmail.com>

Author: crebsy

tests/unit/cli/vyper_json/test_compile_json.py

@@ -5,6 +5,7 @@
 
 import vyper
 from vyper.cli.vyper_json import (
+    VENOM_KEYS,
     compile_from_input_dict,
     compile_json,
     exc_handler_to_dict,
@@ -145,15 +146,11 @@ def json_input(json_data, path):
     )
 
 
-def test_compile_json(input_json, input_bundle):
+def test_compile_json(input_json, input_bundle, experimental_codegen):
     foo_input = input_bundle.load_file("contracts/foo.vy")
     # remove venom related from output formats
     # because they require venom (experimental)
     output_formats = OUTPUT_FORMATS.copy()
-    del output_formats["bb"]
-    del output_formats["bb_runtime"]
-    del output_formats["cfg"]
-    del output_formats["cfg_runtime"]
     foo = compile_from_file_input(
         foo_input,
         output_formats=output_formats,
@@ -198,7 +195,7 @@ def test_compile_json(input_json, input_bundle):
             "ast": data["ast_dict"]["ast"],
             "annotated_ast": data["annotated_ast_dict"]["ast"],
         }
-        assert output_json["contracts"][path][contract_name] == {
+        expected = {
             "abi": data["abi"],
             "devdoc": data["devdoc"],
             "interface": data["interface"],
@@ -220,6 +217,14 @@ def test_compile_json(input_json, input_bundle):
                 "methodIdentifiers": data["method_identifiers"],
             },
         }
+        if experimental_codegen:
+            expected["venom"] = {
+                "bb": repr(data["bb"]),
+                "bb_runtime": repr(data["bb_runtime"]),
+                "cfg": data["cfg"],
+                "cfg_runtime": data["cfg_runtime"],
+            }
+        assert output_json["contracts"][path][contract_name] == expected
 
 
 def test_compilation_targets(input_json):
@@ -237,7 +242,7 @@ def test_compilation_targets(input_json):
     assert list(output_json["contracts"].keys()) == ["contracts/foo.vy", "contracts/bar.vy"]
 
 
-def test_different_outputs(input_bundle, input_json):
+def test_different_outputs(input_bundle, input_json, experimental_codegen):
     input_json["settings"]["outputSelection"] = {
         "contracts/bar.vy": "*",
         "contracts/foo.vy": ["evm.methodIdentifiers"],
@@ -252,16 +257,11 @@ def test_different_outputs(input_bundle, input_json):
 
     foo = contracts["contracts/foo.vy"]["foo"]
     bar = contracts["contracts/bar.vy"]["bar"]
-    assert sorted(bar.keys()) == [
-        "abi",
-        "devdoc",
-        "evm",
-        "interface",
-        "ir",
-        "layout",
-        "metadata",
-        "userdoc",
-    ]
+    expected_keys = ["abi", "devdoc", "evm", "interface", "ir", "layout", "metadata", "userdoc"]
+    if experimental_codegen:
+        expected_keys.append("venom")
+        expected_keys.sort()
+    assert sorted(bar.keys()) == expected_keys
 
     assert sorted(foo.keys()) == ["evm"]
 
@@ -385,13 +385,41 @@ def test_compile_json_with_experimental_codegen():
             "evmVersion": "cancun",
             "optimize": "gas",
             "venomExperimental": True,
-            "search_paths": [],
-            "outputSelection": {"*": ["ast"]},
+            "search_paths": ["."],
+            "outputSelection": {"*": VENOM_KEYS},
         },
     }
+    compiled = compile_from_input_dict(code)
+    expected = compiled[0][PurePath("foo.vy")]
 
     settings = get_settings(code)
     assert settings.experimental_codegen is True
+    output_json = compile_json(code)
+    assert "venom" in output_json["contracts"]["foo.vy"]["foo"]
+    venom = output_json["contracts"]["foo.vy"]["foo"]["venom"]
+    assert venom["bb"] == repr(expected["bb"])
+    assert venom["bb_runtime"] == repr(expected["bb_runtime"])
+    assert venom["cfg"] == expected["cfg"]
+    assert venom["cfg_runtime"] == expected["cfg_runtime"]
+
+
+def test_compile_json_without_experimental_codegen():
+    code = {
+        "language": "Vyper",
+        "sources": {"foo.vy": {"content": "@external\ndef foo() -> bool:\n    return True"}},
+        "settings": {
+            "evmVersion": "cancun",
+            "optimize": "gas",
+            "venomExperimental": False,
+            "search_paths": ["."],
+            "outputSelection": {"*": ["ast"]},
+        },
+    }
+
+    settings = get_settings(code)
+    assert settings.experimental_codegen is False
+    output_json = compile_json(code)
+    assert "venom" not in output_json["contracts"]["foo.vy"]["foo"]
 
 
 def test_compile_json_with_both_venom_aliases():

tests/unit/cli/vyper_json/test_output_selection.py

@@ -3,7 +3,7 @@
 import pytest
 
 from vyper import compiler
-from vyper.cli.vyper_json import TRANSLATE_MAP, get_output_formats
+from vyper.cli.vyper_json import TRANSLATE_MAP, VENOM_KEYS, get_output_formats
 from vyper.exceptions import JSONError
 
 
@@ -33,6 +33,19 @@ def test_translate_map(output):
         "sources": {"foo.vy": ""},
         "settings": {"outputSelection": {"foo.vy": [output[0]]}},
     }
+    if output[0] in ["bb", "bb_runtime", "cfg", "cfg_runtime"]:
+        with pytest.raises(JSONError, match="experimentalCodegen not selected!"):
+            _ = get_output_formats(input_json)
+    else:
+        assert get_output_formats(input_json) == {PurePath("foo.vy"): [output[1]]}
+
+
+@pytest.mark.parametrize("output", TRANSLATE_MAP.items())
+def test_translate_map_with_venom_flag(output):
+    input_json = {
+        "sources": {"foo.vy": ""},
+        "settings": {"venomExperimental": True, "outputSelection": {"foo.vy": [output[0]]}},
+    }
     assert get_output_formats(input_json) == {PurePath("foo.vy"): [output[1]]}
 
 
@@ -41,7 +54,23 @@ def test_star():
         "sources": {"foo.vy": "", "bar.vy": ""},
         "settings": {"outputSelection": {"*": ["*"]}},
     }
-    expected = sorted(set(TRANSLATE_MAP.values()))
+    translate_map = set(TRANSLATE_MAP.values())
+    # if the venom flag is not present
+    for k in VENOM_KEYS:
+        translate_map.remove(k)
+
+    expected = sorted(translate_map)
+    result = get_output_formats(input_json)
+    assert result == {PurePath("foo.vy"): expected, PurePath("bar.vy"): expected}
+
+
+def test_star_with_venom_flag():
+    input_json = {
+        "sources": {"foo.vy": "", "bar.vy": ""},
+        "settings": {"venomExperimental": True, "outputSelection": {"*": ["*"]}},
+    }
+    translate_map = set(TRANSLATE_MAP.values())
+    expected = sorted(translate_map)
     result = get_output_formats(input_json)
     assert result == {PurePath("foo.vy"): expected, PurePath("bar.vy"): expected}
 

vyper/cli/vyper_json.py

@@ -33,8 +33,14 @@
     "metadata": "metadata",
     "layout": "layout",
     "userdoc": "userdoc",
+    "bb": "bb",
+    "bb_runtime": "bb_runtime",
+    "cfg": "cfg",
+    "cfg_runtime": "cfg_runtime",
 }
 
+VENOM_KEYS = ("bb", "bb_runtime", "cfg", "cfg_runtime")
+
 
 def _parse_cli_args():
     return _parse_args(sys.argv[1:])
@@ -251,8 +257,15 @@ def get_output_formats(input_dict: dict) -> dict[PurePath, list[str]]:
             outputs.remove(key)
             outputs.update([i for i in TRANSLATE_MAP if i.startswith(key)])
 
+        should_output_venom = any(
+            input_dict["settings"].get(alias, False)
+            for alias in ("venomExperimental", "experimentalCodegen")
+        )
+
         if "*" in outputs:
             outputs = TRANSLATE_MAP.values()
+            if not should_output_venom:
+                outputs = [k for k in outputs if k not in VENOM_KEYS]
         else:
             try:
                 outputs = [TRANSLATE_MAP[i] for i in outputs]
@@ -261,6 +274,12 @@ def get_output_formats(input_dict: dict) -> dict[PurePath, list[str]]:
 
         outputs = sorted(list(outputs))
 
+        if not should_output_venom and any(k in outputs for k in VENOM_KEYS):
+            selected_venom_keys = [k for k in outputs if k in VENOM_KEYS]
+            raise JSONError(
+                f"requested {selected_venom_keys} but experimentalCodegen not selected!"
+            )
+
         if path == "*":
             output_paths = [PurePath(path) for path in input_dict["sources"].keys()]
         else:
@@ -416,6 +435,18 @@ def format_to_output_dict(compiler_data: dict) -> dict:
             if "source_map_runtime" in data:
                 evm["sourceMap"] = data["source_map_runtime"]
 
+        if any(i in data for i in VENOM_KEYS):
+            venom = {}
+            if "bb" in data:
+                venom["bb"] = repr(data["bb"])
+            if "bb_runtime" in data:
+                venom["bb_runtime"] = repr(data["bb_runtime"])
+            if "cfg" in data:
+                venom["cfg"] = data["cfg"]
+            if "cfg_runtime" in data:
+                venom["cfg_runtime"] = data["cfg_runtime"]
+            output_contracts["venom"] = venom
+
     return output_dict