fix[lang]: stateless modules should not be initialized

tests/functional/codegen/features/test_transient.py

@@ -570,3 +570,15 @@ def foo() -> (uint256[3], uint256, uint256, uint256):
 
     c = get_contract(main, input_bundle=input_bundle)
     assert c.foo() == ([1, 2, 3], 1, 2, 42)
+
+
+def test_transient_is_state(make_input_bundle):
+    lib = """
+message: transient(bool)
+    """
+    main = """
+import lib
+initializes: lib
+        """
+    input_bundle = make_input_bundle({"lib.vy": lib, "main.vy": main})
+    compile_code(main, input_bundle=input_bundle)

tests/functional/codegen/modules/test_nonreentrant.py

@@ -1,5 +1,7 @@
 def test_export_nonreentrant(make_input_bundle, get_contract, tx_failed):
     lib1 = """
+phony: uint32
+
 interface Foo:
     def foo() -> uint256: nonpayable
 
@@ -38,6 +40,8 @@ def __default__():
 
 def test_internal_nonreentrant(make_input_bundle, get_contract, tx_failed):
     lib1 = """
+phony: uint32
+
 interface Foo:
     def foo() -> uint256: nonpayable
 

tests/functional/syntax/modules/test_initializers.py

@@ -835,6 +835,8 @@ def test_uses_skip_import(make_input_bundle):
     lib2 = """
 import lib1
 
+phony: uint32
+
 @internal
 def foo():
     pass
@@ -1418,3 +1420,134 @@ def set_some_mod():
         compile_code(main, input_bundle=input_bundle)
     assert e.value._message == "module `lib3.vy` is used but never initialized!"
     assert e.value._hint is None
+
+
+storage_var_modules = [
+    """
+phony: uint32
+    """,
+    """
+ended: public(bool)
+    """,
+]
+
+
+@pytest.mark.parametrize("module", storage_var_modules)
+def test_initializes_on_modules_with_state_related_vars(module, make_input_bundle):
+    main = """
+import lib
+initializes: lib
+    """
+    input_bundle = make_input_bundle({"lib.vy": module, "main.vy": main})
+    compile_code(main, input_bundle=input_bundle)
+
+
+def test_initializes_on_modules_with_immutables(make_input_bundle):
+    lib = """
+foo: immutable(int128)
+
+@deploy
+def __init__():
+    foo = 2
+    """
+
+    main = """
+import lib
+initializes: lib
+
+@deploy
+def __init__():
+    lib.__init__()
+    """
+    input_bundle = make_input_bundle({"lib.vy": lib, "main.vy": main})
+    compile_code(main, input_bundle=input_bundle)
+
+
+stateless_modules = [
+    """
+    """,
+    """
+@internal
+@pure
+def foo(x: uint256, y: uint256) -> uint256:
+    return unsafe_add(x & y, (x ^ y) >> 1)
+    """,
+    """
+FOO: constant(int128) = 128
+    """,
+]
+
+
+@pytest.mark.parametrize("module", stateless_modules)
+def test_forbids_initializes_on_stateless_modules(module, make_input_bundle):
+    main = """
+import lib
+initializes: lib
+        """
+    input_bundle = make_input_bundle({"lib.vy": module, "main.vy": main})
+    with pytest.raises(StructureException):
+        compile_code(main, input_bundle=input_bundle)
+
+
+def test_initializes_on_modules_with_uses(make_input_bundle):
+    lib0 = """
+import lib1
+uses: lib1
+
+@external
+def foo() -> uint32:
+    return lib1.phony
+           """
+    lib1 = """
+phony: uint32
+           """
+    main = """
+import lib1
+initializes: lib1
+
+import lib0
+initializes: lib0[lib1 := lib1]
+           """
+    input_bundle = make_input_bundle({"lib1.vy": lib1, "lib0.vy": lib0, "main.vy": main})
+    compile_code(main, input_bundle=input_bundle)
+
+
+def test_initializes_on_modules_with_initializes(make_input_bundle):
+    lib0 = """
+import lib1
+initializes: lib1
+           """
+    lib1 = """
+phony: uint32
+           """
+    main = """
+import lib0
+initializes: lib0
+           """
+    input_bundle = make_input_bundle({"lib1.vy": lib1, "lib0.vy": lib0, "main.vy": main})
+    compile_code(main, input_bundle=input_bundle)
+
+
+def test_initializes_on_modules_with_init_function(make_input_bundle):
+    lib = """
+interface Foo:
+    def foo(): payable
+
+@deploy
+def __init__():
+    extcall Foo(self).foo()
+           """
+    main = """
+import lib
+initializes: lib
+
+@deploy
+def __init__():
+    lib.__init__()
+
+@external
+def foo():
+    pass
+           """
+    input_bundle = make_input_bundle({"lib.vy": lib, "main.vy": main})
+    compile_code(main, input_bundle=input_bundle)

tests/unit/compiler/test_abi.py

@@ -218,6 +218,8 @@ def bar(x: {type}):
 
 def test_exports_abi(make_input_bundle):
     lib1 = """
+phony: uint32
+
 @external
 def foo():
     pass
@@ -330,6 +332,8 @@ def __init__():
 def test_event_export_from_init(make_input_bundle):
     # test that events get exported when used in init functions
     lib1 = """
+phony: uint32
+
 event MyEvent:
     pass
 
@@ -361,6 +365,8 @@ def __init__():
 def test_event_export_from_function_export(make_input_bundle):
     # test events used in exported functions are exported
     lib1 = """
+phony: uint32
+
 event MyEvent:
     pass
 
@@ -396,6 +402,8 @@ def foo():
 def test_event_export_unused_function(make_input_bundle):
     # test events in unused functions are not exported
     lib1 = """
+phony: uint32
+
 event MyEvent:
     pass
 

vyper/semantics/analysis/module.py

@@ -37,6 +37,7 @@
     check_modifiability,
     get_exact_type_from_node,
     get_expr_info,
+    is_stateless,
 )
 from vyper.semantics.data_locations import DataLocation
 from vyper.semantics.namespace import Namespace, get_namespace, override_global_namespace
@@ -409,6 +410,10 @@ def visit_InitializesDecl(self, node):
         module_info = get_expr_info(module_ref).module_info
         if module_info is None:
             raise StructureException("Not a module!", module_ref)
+        if is_stateless(module_info.module_node):
+            raise StructureException(
+                f"Cannot initialize a stateless module {module_info.alias}!", module_ref
+            )
 
         used_modules = {i.module_t: i for i in module_info.module_t.used_modules}
 

vyper/semantics/analysis/utils.py

@@ -736,3 +736,19 @@ def validate_kwargs(node: vy_ast.Call, members: dict[str, VyperType], typeclass:
         msg = f"{typeclass} instantiation missing fields:"
         msg += f" {', '.join(list(missing))}"
         raise InstantiationException(msg, node)
+
+
+def is_stateless(module: vy_ast.Module):
+    """
+    Determine whether a module is stateless by examining its top-level declarations.
+    A module has state if it contains storage variables, transient variables, or
+    immutables, or if it includes a "uses" or "initializes" declaration.
+    """
+    for i in module.body:
+        if isinstance(i, (vy_ast.InitializesDecl, vy_ast.UsesDecl)):
+            return False
+        if isinstance(i, vy_ast.VariableDecl) and not i.is_constant:
+            return False
+        if isinstance(i, vy_ast.FunctionDef) and i.name == "__init__":
+            return False
+    return True