fix[lang]: stateless modules should not be initialized

tests/functional/codegen/features/test_transient.py

@@ -570,3 +570,17 @@ def foo() -> (uint256[3], uint256, uint256, uint256):
 
     c = get_contract(main, input_bundle=input_bundle)
     assert c.foo() == ([1, 2, 3], 1, 2, 42)
+
+
+# Testing the `initializes` statement to verify how transient variables
+# interact with and relate to state.
+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_module_variables.py

@@ -158,6 +158,8 @@ def increment_counter():
 
 uses: lib1
 
+phony: uint32
+
 @internal
 def get_lib1_counter() -> uint256:
     return lib1.counter

tests/functional/syntax/modules/test_initializers.py

@@ -277,6 +277,8 @@ def test_initializer_list_module_mismatch(make_input_bundle):
 
 uses: lib1
 
+phony: uint32
+
 @internal
 def foo():
     lib1.counter += 1
@@ -835,6 +837,8 @@ def test_uses_skip_import(make_input_bundle):
     lib2 = """
 import lib1
 
+phony: uint32
+
 @internal
 def foo():
     pass
@@ -1399,6 +1403,7 @@ def test_global_initialize_missed_import_hint(make_input_bundle, chdir_tmp_path)
 import lib3
 
 uses: lib3
+phony: uint32
 
 @external
 def set_some_mod():
@@ -1418,3 +1423,147 @@ 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
+
+
+initializable_modules = [
+    """
+phony: uint32
+    """,
+    """
+ended: public(bool)
+    """,
+    """
+@external
+@nonreentrant
+def foo():
+    pass
+    """,
+    """
+@internal
+@nonreentrant
+def foo():
+    pass
+    """,
+]
+
+
+@pytest.mark.parametrize("module", initializable_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})
+    with pytest.raises(StructureException):
+        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
@@ -361,6 +363,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 +400,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
 
@@ -639,6 +645,8 @@ def update_counter():
 import lib1
 uses: lib1
 
+phony: uint32
+
 @internal
 def use_lib1():
     lib1.update_counter()

vyper/semantics/analysis/module.py

@@ -409,6 +409,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 module_info.module_t.is_not_initializable:
+            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/types/module.py

@@ -444,19 +444,19 @@ def find_module_info(self, needle: "ModuleT") -> Optional["ModuleInfo"]:
                 return s
         return None
 
-    @property
+    @cached_property
     def variable_decls(self):
         return self._module.get_children(vy_ast.VariableDecl)
 
-    @property
+    @cached_property
     def uses_decls(self):
         return self._module.get_children(vy_ast.UsesDecl)
 
-    @property
+    @cached_property
     def initializes_decls(self):
         return self._module.get_children(vy_ast.InitializesDecl)
 
-    @property
+    @cached_property
     def exports_decls(self):
         return self._module.get_children(vy_ast.ExportsDecl)
 
@@ -469,7 +469,7 @@ def used_modules(self):
                 ret.append(used_module)
         return ret
 
-    @property
+    @cached_property
     def initialized_modules(self):
         # modules which are initialized to
         ret = []
@@ -559,3 +559,24 @@ def immutable_section_bytes(self):
     @cached_property
     def interface(self):
         return InterfaceT.from_ModuleT(self)
+
+    @cached_property
+    def is_not_initializable(self):
+        """
+        Determine whether ModuleT 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 "initializes"
+        declaration, or any nonreentrancy locks.
+        """
+        if len(self.initializes_decls) > 0:
+            return False
+        if any(not v.is_constant for v in self.variable_decls):
+            return False
+        if self.init_function is not None:
+            return False
+
+        for fun in self.functions.values():
+            if fun.nonreentrant:
+                return False
+
+        return True