refactor[codegen]: split codegen packages

.github/scripts/measure_bytecode.py

@@ -29,10 +29,10 @@ def get_example_vy_filenames(limit: int | None = None):
     return files[:limit] if limit else files
 
 
-def compile_one(source_code: str, opt_level: OptimizationLevel, experimental: bool) -> tuple[int | None, str | None]:
+def compile_one(source_code: str, opt_level: OptimizationLevel, legacy: bool) -> tuple[int | None, str | None]:
     """Compile with given settings. Returns (size, error)."""
     try:
-        settings = Settings(experimental_codegen=experimental, optimize=opt_level)
+        settings = Settings(legacy_codegen=legacy, optimize=opt_level)
         result = compiler.compile_code(source_code, settings=settings, output_formats=["bytecode"])
         bytecode = result.get("bytecode", "")
         size = (len(bytecode) - 2) // 2 if bytecode.startswith("0x") else len(bytecode) // 2
@@ -55,11 +55,11 @@ def measure_contract(filename: str) -> tuple[str, dict]:
 
     results = {
         "legacy": {
-            name: dict(zip(["size", "error"], compile_one(source_code, opt, False)))
+            name: dict(zip(["size", "error"], compile_one(source_code, opt, True)))
             for name, opt in LEGACY_OPT_LEVELS.items()
         },
         "venom": {
-            name: dict(zip(["size", "error"], compile_one(source_code, opt, True)))
+            name: dict(zip(["size", "error"], compile_one(source_code, opt, False)))
             for name, opt in VENOM_OPT_LEVELS.items()
         },
     }

.github/workflows/test.yml

@@ -114,7 +114,7 @@ jobs:
       py${{ matrix.python-version[1] || '311' }}\
       -opt-${{ matrix.opt-mode || 'gas' }}\
       ${{ matrix.debug && '-debug' || '' }}\
-      ${{ matrix.experimental-codegen && '-experimental' || '' }}\
+      ${{ matrix.legacy && '-legacy' || '' }}\
       -${{ matrix.evm-version || 'prague' }}\
       -${{ matrix.evm-backend || 'revm' }}"
     strategy:
@@ -125,7 +125,7 @@ jobs:
         opt-mode: [gas, none, codesize, O1, O2, O3]
         debug: [true, false]
         evm-version: [prague]  # note: when upgrading, check the "include" section below for conflicting jobs
-        experimental-codegen: [false]
+        legacy: [false]
         evm-backend: [revm]
 
         # https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs#expanding-or-adding-matrix-configurations
@@ -152,18 +152,18 @@ jobs:
           - evm-backend: py-evm
             evm-version: prague
 
-          # test experimental pipeline
-          - experimental-codegen: true
+          # test legacy pipeline
+          - legacy: true
             opt-mode: gas
-          - experimental-codegen: true
+          - legacy: true
             opt-mode: none
-          - experimental-codegen: true
+          - legacy: true
             opt-mode: codesize
-          - experimental-codegen: true
+          - legacy: true
             opt-mode: O1
-          - experimental-codegen: true
+          - legacy: true
             opt-mode: O2
-          - experimental-codegen: true
+          - legacy: true
             opt-mode: O3
 
           # run across other python versions. we don't really need to run all
@@ -202,7 +202,7 @@ jobs:
         --evm-version ${{ matrix.evm-version || 'prague' }}
         --evm-backend ${{ matrix.evm-backend || 'revm' }}
         ${{ matrix.debug && '--enable-compiler-debug-mode' || '' }}
-        ${{ matrix.experimental-codegen && '--experimental-codegen' || '' }}
+        ${{ matrix.legacy && '--legacy' || '' }}
         --cov-config=setup.cfg
         --cov=vyper
         tests/

tests/conftest.py

@@ -18,7 +18,7 @@
 from tests.exports import TestExporter
 from tests.utils import working_directory
 from vyper import compiler
-from vyper.codegen.ir_node import IRnode
+from vyper.codegen_legacy.ir_node import IRnode
 from vyper.compiler import compile_code
 from vyper.compiler.input_bundle import FilesystemInputBundle
 from vyper.compiler.settings import OptimizationLevel, Settings, set_global_settings
@@ -44,7 +44,8 @@ def pytest_addoption(parser):
         help="change optimization mode",
     )
     parser.addoption("--enable-compiler-debug-mode", action="store_true")
-    parser.addoption("--experimental-codegen", action="store_true")
+    parser.addoption("--experimental-codegen", action="store_true", default=True)
+    parser.addoption("--legacy", action="store_true", default=False)
     parser.addoption("--tracing", action="store_true")
     parser.addoption("--hevm", action="store_true")
 
@@ -88,9 +89,13 @@ def debug(pytestconfig):
 
 @pytest.fixture(scope="session")
 def experimental_codegen(pytestconfig):
-    ret = pytestconfig.getoption("experimental_codegen")
-    assert isinstance(ret, bool)
-    return ret
+    """Returns True for venom codegen, False for legacy.
+    Kept as 'experimental_codegen' for backward compat in test markers."""
+    legacy = pytestconfig.getoption("legacy")
+    if legacy:
+        return False
+    # Venom is now the default
+    return True
 
 
 @pytest.fixture(scope="session")
@@ -242,7 +247,7 @@ def compiler_settings(optimize, experimental_codegen, evm_version, debug):
     settings = Settings(
         optimize=optimize,
         evm_version=evm_version,
-        experimental_codegen=experimental_codegen,
+        legacy_codegen=not experimental_codegen,
         debug=debug,
     )
     set_global_settings(settings)
@@ -272,10 +277,10 @@ def fn(source_code, *args, **kwargs):
         global _HEVM_MARKER
         if hevm and _HEVM_MARKER is not None:
             settings1 = copy.copy(compiler_settings)
-            settings1.experimental_codegen = False
+            settings1.legacy_codegen = True  # legacy
             settings1.optimize = OptimizationLevel.NONE
             settings2 = copy.copy(compiler_settings)
-            settings2.experimental_codegen = True
+            settings2.legacy_codegen = False  # venom
             settings2.optimize = OptimizationLevel.NONE
 
             bytecode1 = compile_code(

tests/exports.md

@@ -139,7 +139,7 @@ It is based on `Settings.as_dict()`, except `enable_decimals` is always included
 {
   "optimize": <string>,
   "evm_version": <string>,
-  "experimental_codegen": <bool>,
+  "legacy_codegen": <bool>,
   "debug": <bool>,
   "enable_decimals": <bool>,
   "nonreentrancy_by_default": <bool>,
@@ -164,7 +164,7 @@ It is based on `Settings.as_dict()`, except `enable_decimals` is always included
 |-------|------|-------------|
 | `optimize` | `string` | Optimization level: `"none"`, `"gas"`, `"codesize"` |
 | `evm_version` | `string` | Target EVM version: `"cancun"`, `"shanghai"`, `"prague"`, etc. |
-| `experimental_codegen` | `bool` | Whether Venom (experimental codegen) is enabled |
+| `legacy_codegen` | `bool` | Whether legacy IRnode codegen is used (default: False = Venom) |
 | `debug` | `bool` | Whether debug mode is enabled |
 | `enable_decimals` | `bool` | Whether decimal type is enabled |
 | `nonreentrancy_by_default` | `bool` | Whether functions are non-reentrant by default |

tests/functional/builtins/codegen/test_abi_decode_fuzz.py

@@ -6,7 +6,7 @@
 from eth.codecs import abi
 
 from tests.evm_backends.base_env import EvmError
-from vyper.codegen.core import calculate_type_for_external_return, needs_external_call_wrap
+from vyper.codegen_legacy.core import calculate_type_for_external_return, needs_external_call_wrap
 from vyper.semantics.types import (
     AddressT,
     BoolT,

tests/functional/codegen/features/test_alloca_loop_param_init.py

@@ -13,7 +13,7 @@
 def no_inline_settings(compiler_settings):
     """Create settings with function inlining disabled (venom only)."""
     settings = copy.copy(compiler_settings)
-    if settings.experimental_codegen:
+    if not settings.legacy_codegen:
         settings.venom_flags = VenomOptimizationFlags(disable_inlining=True)
     return settings
 

tests/functional/codegen/features/test_mem2var_alloca_bug.py

@@ -19,7 +19,7 @@
 def no_inline_settings(compiler_settings):
     """Create settings with function inlining disabled (venom only)."""
     settings = copy.copy(compiler_settings)
-    if settings.experimental_codegen:
+    if not settings.legacy_codegen:
         settings.venom_flags = VenomOptimizationFlags(disable_inlining=True)
     return settings
 

tests/functional/codegen/features/test_mem2var_mstore_bug.py

@@ -16,7 +16,7 @@
 def no_inline_settings(compiler_settings):
     """Create settings with function inlining disabled (venom only)."""
     settings = copy.copy(compiler_settings)
-    if settings.experimental_codegen:
+    if not settings.legacy_codegen:
         settings.venom_flags = VenomOptimizationFlags(disable_inlining=True)
     return settings
 

tests/functional/codegen/test_selector_table.py

@@ -3,7 +3,7 @@
 from hypothesis import given, settings
 
 import vyper.utils as utils
-from vyper.codegen.jumptable_utils import (
+from vyper.codegen_legacy.jumptable_utils import (
     generate_dense_jumptable_info,
     generate_sparse_jumptable_buckets,
 )

tests/functional/codegen/test_selector_table_stability.py

@@ -1,4 +1,4 @@
-from vyper.codegen.jumptable_utils import generate_sparse_jumptable_buckets
+from vyper.codegen_legacy.jumptable_utils import generate_sparse_jumptable_buckets
 from vyper.compiler import compile_code
 from vyper.compiler.settings import OptimizationLevel, Settings
 
@@ -9,7 +9,9 @@ def test_dense_jumptable_stability():
     code = "\n".join(f"@external\ndef {name}():\n  pass" for name in function_names)
 
     output = compile_code(
-        code, output_formats=["asm_runtime"], settings=Settings(optimize=OptimizationLevel.CODESIZE)
+        code,
+        output_formats=["asm_runtime"],
+        settings=Settings(optimize=OptimizationLevel.CODESIZE, legacy_codegen=True),
     )
 
     # test that the selector table data is stable across different runs

tests/functional/codegen/types/numbers/test_exponents.py

@@ -2,7 +2,7 @@
 from hypothesis import example, given, settings
 from hypothesis import strategies as st
 
-from vyper.codegen.arithmetic import calculate_largest_base, calculate_largest_power
+from vyper.codegen_legacy.arithmetic import calculate_largest_base, calculate_largest_power
 from vyper.compiler import compile_code
 from vyper.exceptions import InvalidLiteral
 

tests/functional/codegen/types/test_identifier_naming.py

@@ -2,7 +2,7 @@
 
 from vyper.ast.identifiers import RESERVED_KEYWORDS
 from vyper.builtins.functions import BUILTIN_FUNCTIONS
-from vyper.codegen.expr import ENVIRONMENT_VARIABLES
+from vyper.codegen_legacy.expr import ENVIRONMENT_VARIABLES
 from vyper.exceptions import NamespaceCollision, StructureException, SyntaxException
 from vyper.semantics.types.primitives import AddressT
 

tests/functional/venom/test_venom_repr.py

@@ -40,7 +40,7 @@ def test_round_trip_examples(path: Path, debug, optimize, compiler_settings, req
     """
     Check all examples round trip
     """
-    if not compiler_settings.experimental_codegen:
+    if not compiler_settings.legacy_codegen:
         pytest.skip("tests n/a when venom is not enabled")
 
     if debug and optimize == OptimizationLevel.CODESIZE:
@@ -76,7 +76,7 @@ def test_round_trip_sources(vyper_source, debug, optimize, compiler_settings, re
     """
     Test vyper_sources round trip
     """
-    if not compiler_settings.experimental_codegen:
+    if not compiler_settings.legacy_codegen:
         pytest.skip("tests n/a when venom is not enabled")
 
     vyper_source = textwrap.dedent(vyper_source)
@@ -105,7 +105,7 @@ def _helper1(vyper_source, optimize, input_bundle=None):
     """
     from vyper.compiler.settings import Settings
 
-    settings = Settings(experimental_codegen=True)
+    settings = Settings(legacy_codegen=False)
     # note: compiling any later stage than ir_runtime like `asm` or
     # `bytecode` modifies the ir_runtime data structure in place and results
     # in normalization of the venom cfg (which breaks again make_ssa)
@@ -138,7 +138,7 @@ def _helper2(vyper_source, optimize, compiler_settings, input_bundle=None):
     """
     settings = copy.copy(compiler_settings)
     # bytecode equivalence only makes sense if we use venom pipeline
-    settings.experimental_codegen = True
+    settings.legacy_codegen = False
 
     out = compile_code(
         vyper_source, input_bundle=input_bundle, settings=settings, output_formats=["ir_runtime"]

tests/unit/ast/test_pre_parser.py

@@ -206,8 +206,8 @@ def test_parse_pragmas(code, pre_parse_settings, compiler_data_settings, mock_ve
         # None is sentinel here meaning that nothing changed
         compiler_data_settings = pre_parse_settings
 
-    # experimental_codegen is False by default
-    compiler_data_settings.experimental_codegen = False
+    # legacy_codegen is False by default (venom is default)
+    compiler_data_settings.legacy_codegen = False
 
     assert compiler_data.settings == compiler_data_settings
 
@@ -226,10 +226,10 @@ def test_parse_pragmas(code, pre_parse_settings, compiler_data_settings, mock_ve
 def test_parse_venom_pragma(code):
     pre_parser = PreParser(is_interface=False)
     pre_parser.parse(code)
-    assert pre_parser.settings.experimental_codegen is True
+    assert pre_parser.settings.legacy_codegen is False  # venom = not legacy
 
     compiler_data = CompilerData(code)
-    assert compiler_data.settings.experimental_codegen is True
+    assert compiler_data.settings.legacy_codegen is False
 
 
 invalid_pragmas = [

tests/unit/cli/vyper_json/test_compile_json.py

@@ -393,7 +393,7 @@ def test_compile_json_with_experimental_codegen():
     expected = compiled[0][PurePath("foo.vy")]
 
     settings = get_settings(code)
-    assert settings.experimental_codegen is True
+    assert settings.legacy_codegen is False  # venom = not legacy
     output_json = compile_json(code)
     assert "venom" in output_json["contracts"]["foo.vy"]["foo"]
     venom = output_json["contracts"]["foo.vy"]["foo"]["venom"]
@@ -455,7 +455,7 @@ def test_compile_json_without_experimental_codegen():
     }
 
     settings = get_settings(code)
-    assert settings.experimental_codegen is False
+    assert settings.legacy_codegen is True  # legacy
     output_json = compile_json(code)
     assert "venom" not in output_json["contracts"]["foo.vy"]["foo"]
 

tests/unit/cli/vyper_json/test_get_settings.py

@@ -32,12 +32,19 @@ def test_valid_evm(evm_version_str):
     assert evm_version_str == get_evm_version({"settings": {"evmVersion": evm_version_str}})
 
 
-def test_experimental_codegen_settings():
+def test_codegen_settings():
     input_json = {"settings": {}}
-    assert get_settings(input_json).experimental_codegen is None
+    assert get_settings(input_json).legacy_codegen is None
 
+    input_json = {"settings": {"legacyCodegen": True}}
+    assert get_settings(input_json).legacy_codegen is True
+
+    input_json = {"settings": {"legacyCodegen": False}}
+    assert get_settings(input_json).legacy_codegen is False
+
+    # deprecated: experimentalCodegen (inverted)
     input_json = {"settings": {"experimentalCodegen": True}}
-    assert get_settings(input_json).experimental_codegen is True
+    assert get_settings(input_json).legacy_codegen is False  # venom = not legacy
 
     input_json = {"settings": {"experimentalCodegen": False}}
-    assert get_settings(input_json).experimental_codegen is False
+    assert get_settings(input_json).legacy_codegen is True  # legacy

tests/unit/compiler/asm/test_asm_optimizer.py

@@ -80,7 +80,7 @@ def __init__():
 # need to test this using asm anymore.
 @pytest.mark.parametrize("code", codes)
 def test_dead_code_eliminator(code):
-    c = CompilerData(code, settings=Settings(optimize=OptimizationLevel.NONE))
+    c = CompilerData(code, settings=Settings(optimize=OptimizationLevel.NONE, legacy_codegen=True))
 
     # get the labels
     initcode_labels = [i for i in c.assembly if isinstance(i, Label)]

tests/unit/compiler/ir/test_compile_ir.py

@@ -1,6 +1,6 @@
 import pytest
 
-from vyper.codegen.ir_node import IRnode
+from vyper.codegen_legacy.ir_node import IRnode
 from vyper.evm.opcodes import version_check
 from vyper.ir import compile_ir
 from vyper.ir.s_expressions import parse_s_exp

tests/unit/compiler/ir/test_optimize_ir.py

@@ -1,6 +1,6 @@
 import pytest
 
-from vyper.codegen.ir_node import IRnode
+from vyper.codegen_legacy.ir_node import IRnode
 from vyper.evm.opcodes import version_check
 from vyper.exceptions import StaticAssertionException
 from vyper.ir import optimizer

tests/unit/compiler/test_default_settings.py

@@ -1,4 +1,4 @@
-from vyper.codegen import core
+from vyper.codegen_legacy import core
 from vyper.compiler.phases import CompilerData
 from vyper.compiler.settings import OptimizationLevel, _is_debug_mode
 

tests/unit/compiler/test_symbol_map.py

@@ -18,7 +18,7 @@ def baz(a: uint256) -> uint256:
 
 def test_simple_map():
     code = TEST_CODE
-    settings = Settings(experimental_codegen=True, optimize=OptimizationLevel.GAS)
+    settings = Settings(legacy_codegen=False, optimize=OptimizationLevel.GAS)
     settings.venom_flags = VenomOptimizationFlags(disable_inlining=True)
     output = compile_code(
         code, output_formats=["symbol_map_runtime", "metadata"], settings=settings