feat: implement "stateless" modules

vyper/builtins/_utils.py

@@ -1,10 +1,10 @@
 from vyper.ast import parse_to_ast
 from vyper.codegen.context import Context
-from vyper.codegen.global_context import GlobalContext
 from vyper.codegen.stmt import parse_body
 from vyper.semantics.analysis.local import FunctionNodeVisitor
 from vyper.semantics.namespace import Namespace, override_global_namespace
 from vyper.semantics.types.function import ContractFunctionT, FunctionVisibility, StateMutability
+from vyper.semantics.types.module import ModuleT
 
 
 def _strip_source_pos(ir_node):
@@ -29,9 +29,7 @@
         # annotate the AST as side effects.
         FunctionNodeVisitor(ast_code, ast_code.body[0], namespace)
 
-    new_context = Context(
-        vars_=variables, global_ctx=GlobalContext(), memory_allocator=memory_allocator
-    )
+    new_context = Context(vars_=variables, global_ctx=ModuleT(), memory_allocator=memory_allocator)
     generated_ir = parse_body(ast_code.body[0].body, new_context)
     # strip source position info from the generated_ir since
     # it doesn't make any sense (e.g. the line numbers will start from 0

vyper/codegen/context.py

@@ -48,7 +48,7 @@ def __repr__(self):
 class Context:
     def __init__(
         self,
-        global_ctx,
+        module_ctx,
         memory_allocator,
         vars_=None,
         forvars=None,
@@ -60,7 +60,7 @@ def __init__(
         self.vars = vars_ or {}
 
         # Global variables, in the form (name, storage location, type)
-        self.globals = global_ctx.variables
+        self.globals = module_ctx.variables
 
         # Variables defined in for loops, e.g. for i in range(6): ...
         self.forvars = forvars or {}
@@ -75,8 +75,8 @@ def __init__(
         # Whether we are currently parsing a range expression
         self.in_range_expr = False
 
-        # store global context
-        self.global_ctx = global_ctx
+        # store module context
+        self.module_ctx = module_ctx
 
         # full function type
         self.func_t = func_t

vyper/codegen/expr.py

@@ -690,7 +690,7 @@ def parse_Call(self):
             # type annotations are consistently available
             isinstance(self.expr.func, vy_ast.Attribute)
             and isinstance(self.expr.func.value, vy_ast.Name)
-            and self.expr.func.value.id == "self"
+            and self.expr.func._metadata["type"].is_internal
         ):
             return self_call.ir_for_self_call(self.expr, self.context)
         else:

vyper/codegen/function_definitions/common.py

@@ -7,12 +7,12 @@
 from vyper.codegen.core import check_single_exit
 from vyper.codegen.function_definitions.external_function import generate_ir_for_external_function
 from vyper.codegen.function_definitions.internal_function import generate_ir_for_internal_function
-from vyper.codegen.global_context import GlobalContext
 from vyper.codegen.ir_node import IRnode
 from vyper.codegen.memory_allocator import MemoryAllocator
 from vyper.exceptions import CompilerPanic
 from vyper.semantics.types import VyperType
 from vyper.semantics.types.function import ContractFunctionT
+from vyper.semantics.types.module import ModuleT
 from vyper.utils import MemoryPositions, calc_mem_gas, mkalphanum
 
 
@@ -94,7 +94,7 @@ class InternalFuncIR(FuncIR):
 
 # TODO: should split this into external and internal ir generation?
 def generate_ir_for_function(
-    code: vy_ast.FunctionDef, global_ctx: GlobalContext, is_ctor_context: bool = False
+    code: vy_ast.FunctionDef, module_ctx: ModuleT, is_ctor_context: bool = False
 ) -> FuncIR:
     """
     Parse a function and produce IR code for the function, includes:
@@ -126,7 +126,7 @@ def generate_ir_for_function(
 
     context = Context(
         vars_=None,
-        global_ctx=global_ctx,
+        module_ctx=module_ctx,
         memory_allocator=memory_allocator,
         constancy=Constancy.Mutable if func_t.is_mutable else Constancy.Constant,
         func_t=func_t,

vyper/codegen/module.py

@@ -5,33 +5,31 @@
 from vyper.codegen import core, jumptable_utils
 from vyper.codegen.core import shr
 from vyper.codegen.function_definitions import generate_ir_for_function
-from vyper.codegen.global_context import GlobalContext
 from vyper.codegen.ir_node import IRnode
 from vyper.compiler.settings import _is_debug_mode
 from vyper.exceptions import CompilerPanic
-from vyper.utils import method_id_int
+from vyper.semantics.types.module import ModuleT
+from vyper.utils import OrderedSet, method_id_int
 
 
-def _topsort_helper(functions, lookup):
+def _topsort(functions):
     #  single pass to get a global topological sort of functions (so that each
     # function comes after each of its callees). may have duplicates, which get
-    # filtered out in _topsort()
+    # filtered out at the end
 
     ret = []
     for f in functions:
-        # called_functions is a list of ContractFunctions, need to map
-        # back to FunctionDefs.
-        callees = [lookup[t.name] for t in f._metadata["type"].called_functions]
-        ret.extend(_topsort_helper(callees, lookup))
-        ret.append(f)
+        fn_t = f._metadata["type"]
+        if not fn_t.is_external:
+            continue
 
-    return ret
+        for internal_fn in fn_t.reachable_internal_functions:
+            assert internal_fn.ast_def is not None
+            ret.append(internal_fn.ast_def)
 
+        ret.append(f)
 
-def _topsort(functions):
-    lookup = {f.name: f for f in functions}
-    # strip duplicates
-    return list(dict.fromkeys(_topsort_helper(functions, lookup)))
+    return list(OrderedSet.fromkeys(ret))
 
 
 def _is_constructor(func_ast):
@@ -86,12 +84,12 @@ def _ir_for_internal_function(func_ast, *args, **kwargs):
     return generate_ir_for_function(func_ast, *args, **kwargs).func_ir
 
 
-def _generate_external_entry_points(external_functions, global_ctx):
+def _generate_external_entry_points(external_functions, module_ctx):
     entry_points = {}  # map from ABI sigs to ir code
     sig_of = {}  # reverse map from method ids to abi sig
 
     for code in external_functions:
-        func_ir = generate_ir_for_function(code, global_ctx)
+        func_ir = generate_ir_for_function(code, module_ctx)
         for abi_sig, entry_point in func_ir.entry_points.items():
             method_id = method_id_int(abi_sig)
             assert abi_sig not in entry_points
@@ -113,13 +111,13 @@ def _generate_external_entry_points(external_functions, global_ctx):
 # into a bucket (of about 8-10 items), and then uses perfect hash
 # to select the final function.
 # costs about 212 gas for typical function and 8 bytes of code (+ ~87 bytes of global overhead)
-def _selector_section_dense(external_functions, global_ctx):
+def _selector_section_dense(external_functions, module_ctx):
     function_irs = []
 
     if len(external_functions) == 0:
         return IRnode.from_list(["seq"])
 
-    entry_points, sig_of = _generate_external_entry_points(external_functions, global_ctx)
+    entry_points, sig_of = _generate_external_entry_points(external_functions, module_ctx)
 
     # generate the label so the jumptable works
     for abi_sig, entry_point in entry_points.items():
@@ -264,13 +262,13 @@ def _selector_section_dense(external_functions, global_ctx):
 # a bucket, and then descends into linear search from there.
 # costs about 126 gas for typical (nonpayable, >0 args, avg bucket size 1.5)
 # function and 24 bytes of code (+ ~23 bytes of global overhead)
-def _selector_section_sparse(external_functions, global_ctx):
+def _selector_section_sparse(external_functions, module_ctx):
     ret = ["seq"]
 
     if len(external_functions) == 0:
         return ret
 
-    entry_points, sig_of = _generate_external_entry_points(external_functions, global_ctx)
+    entry_points, sig_of = _generate_external_entry_points(external_functions, module_ctx)
 
     n_buckets, buckets = jumptable_utils.generate_sparse_jumptable_buckets(entry_points.keys())
 
@@ -367,14 +365,14 @@ def _selector_section_sparse(external_functions, global_ctx):
 # O(n) linear search for the method id
 # mainly keep this in for backends which cannot handle the indirect jump
 # in selector_section_dense and selector_section_sparse
-def _selector_section_linear(external_functions, global_ctx):
+def _selector_section_linear(external_functions, module_ctx):
     ret = ["seq"]
     if len(external_functions) == 0:
         return ret
 
     ret.append(["if", ["lt", "calldatasize", 4], ["goto", "fallback"]])
 
-    entry_points, sig_of = _generate_external_entry_points(external_functions, global_ctx)
+    entry_points, sig_of = _generate_external_entry_points(external_functions, module_ctx)
 
     dispatcher = ["seq"]
 
@@ -402,10 +400,10 @@ def _selector_section_linear(external_functions, global_ctx):
     return ret
 
 
-# take a GlobalContext, and generate the runtime and deploy IR
-def generate_ir_for_module(global_ctx: GlobalContext) -> tuple[IRnode, IRnode]:
+# take a ModuleT, and generate the runtime and deploy IR
+def generate_ir_for_module(module_ctx: ModuleT) -> tuple[IRnode, IRnode]:
     # order functions so that each function comes after all of its callees
-    function_defs = _topsort(global_ctx.functions)
+    function_defs = _topsort(module_ctx.functions)
 
     runtime_functions = [f for f in function_defs if not _is_constructor(f)]
     init_function = next((f for f in function_defs if _is_constructor(f)), None)
@@ -421,20 +419,20 @@ def generate_ir_for_module(global_ctx: GlobalContext) -> tuple[IRnode, IRnode]:
 
     # compile internal functions first so we have the function info
     for func_ast in internal_functions:
-        func_ir = _ir_for_internal_function(func_ast, global_ctx, False)
+        func_ir = _ir_for_internal_function(func_ast, module_ctx, False)
         internal_functions_ir.append(IRnode.from_list(func_ir))
 
     if core._opt_none():
-        selector_section = _selector_section_linear(external_functions, global_ctx)
+        selector_section = _selector_section_linear(external_functions, module_ctx)
     # dense vs sparse global overhead is amortized after about 4 methods.
     # (--debug will force dense selector table anyway if _opt_codesize is selected.)
     elif core._opt_codesize() and (len(external_functions) > 4 or _is_debug_mode()):
-        selector_section = _selector_section_dense(external_functions, global_ctx)
+        selector_section = _selector_section_dense(external_functions, module_ctx)
     else:
-        selector_section = _selector_section_sparse(external_functions, global_ctx)
+        selector_section = _selector_section_sparse(external_functions, module_ctx)
 
     if default_function:
-        fallback_ir = _ir_for_fallback_or_ctor(default_function, global_ctx)
+        fallback_ir = _ir_for_fallback_or_ctor(default_function, module_ctx)
     else:
         fallback_ir = IRnode.from_list(
             ["revert", 0, 0], annotation="Default function", error_msg="fallback function"
@@ -447,24 +445,24 @@ def generate_ir_for_module(global_ctx: GlobalContext) -> tuple[IRnode, IRnode]:
     runtime.extend(internal_functions_ir)
 
     deploy_code: List[Any] = ["seq"]
-    immutables_len = global_ctx.immutable_section_bytes
+    immutables_len = module_ctx.immutable_section_bytes
     if init_function:
         # cleanly rerun codegen for internal functions with `is_ctor_ctx=True`
         ctor_internal_func_irs = []
         internal_functions = [f for f in runtime_functions if _is_internal(f)]
         for f in internal_functions:
             init_func_t = init_function._metadata["type"]
-            if f.name not in init_func_t.recursive_calls:
+            if f.name not in init_func_t.reachable_internal_functions:
                 # unreachable code, delete it
                 continue
 
-            func_ir = _ir_for_internal_function(f, global_ctx, is_ctor_context=True)
+            func_ir = _ir_for_internal_function(f, module_ctx, is_ctor_context=True)
             ctor_internal_func_irs.append(func_ir)
 
         # generate init_func_ir after callees to ensure they have analyzed
         # memory usage.
         # TODO might be cleaner to separate this into an _init_ir helper func
-        init_func_ir = _ir_for_fallback_or_ctor(init_function, global_ctx, is_ctor_context=True)
+        init_func_ir = _ir_for_fallback_or_ctor(init_function, module_ctx, is_ctor_context=True)
 
         # pass the amount of memory allocated for the init function
         # so that deployment does not clobber while preparing immutables

vyper/compiler/phases.py

@@ -7,14 +7,14 @@
 from vyper import ast as vy_ast
 from vyper.codegen import module
 from vyper.codegen.core import anchor_opt_level
-from vyper.codegen.global_context import GlobalContext
 from vyper.codegen.ir_node import IRnode
 from vyper.compiler.input_bundle import FilesystemInputBundle, InputBundle
 from vyper.compiler.settings import OptimizationLevel, Settings
 from vyper.exceptions import StructureException
 from vyper.ir import compile_ir, optimizer
 from vyper.semantics import set_data_positions, validate_semantics
 from vyper.semantics.types.function import ContractFunctionT
+from vyper.semantics.types.module import ModuleT
 from vyper.typing import StorageLayout
 
 DEFAULT_CONTRACT_NAME = PurePath("VyperContract.vy")
@@ -34,7 +34,7 @@ class CompilerData:
         Top-level Vyper AST node
     vyper_module_folded : vy_ast.Module
         Folded Vyper AST
-    global_ctx : GlobalContext
+    global_ctx : ModuleT
         Sorted, contextualized representation of the Vyper AST
     ir_nodes : IRnode
         IR used to generate deployment bytecode
@@ -154,8 +154,8 @@ def storage_layout(self) -> StorageLayout:
         return storage_layout
 
     @property
-    def global_ctx(self) -> GlobalContext:
-        return GlobalContext(self.vyper_module_folded)
+    def global_ctx(self) -> ModuleT:
+        return ModuleT(self.vyper_module_folded)
 
     @cached_property
     def _ir_output(self):
@@ -282,9 +282,7 @@ def generate_folded_ast(
     return vyper_module_folded, symbol_tables
 
 
-def generate_ir_nodes(
-    global_ctx: GlobalContext, optimize: OptimizationLevel
-) -> tuple[IRnode, IRnode]:
+def generate_ir_nodes(global_ctx: ModuleT, optimize: OptimizationLevel) -> tuple[IRnode, IRnode]:
     """
     Generate the intermediate representation (IR) from the contextualized AST.
 
@@ -295,7 +293,7 @@ def generate_ir_nodes(
 
     Arguments
     ---------
-    global_ctx : GlobalContext
+    global_ctx: ModuleT
         Contextualized Vyper AST
 
     Returns

vyper/semantics/analysis/local.py

@@ -453,7 +453,9 @@ def visit_For(self, node):
                         call_node,
                     )
 
-                for name in self.namespace["self"].typ.members[fn_name].recursive_calls:
+                for name in (
+                    self.namespace["self"].typ.members[fn_name].reachable_internal_functions
+                ):
                     # check for indirect modification
                     fn_node = self.vyper_module.get_children(vy_ast.FunctionDef, {"name": name})[0]
                     if _check_iterator_modification(node.iter, fn_node):