feat: implement "stateless" modules

tests/unit/cli/vyper_compile/test_compile_files.py

@@ -42,7 +42,7 @@ def foo() -> FooStruct:
 
 @external
 def bar(a: address) -> FooStruct:
-    return {}(a).bar()
+    return {}.at(a).bar()
 """
 
 BAR_CODE = """

vyper/ast/annotation.py

@@ -19,11 +19,11 @@ def __init__(
         modification_offsets: Optional[ModificationOffsets],
         tokens: asttokens.ASTTokens,
         source_id: int,
-        contract_name: Optional[str],
+        module_path: Optional[str] = None,
     ):
         self._tokens = tokens
         self._source_id = source_id
-        self._contract_name = contract_name
+        self._module_path = module_path
         self._source_code: str = source_code
         self.counter: int = 0
         self._modification_offsets = {}
@@ -83,7 +83,8 @@ def _visit_docstring(self, node):
         return node
 
     def visit_Module(self, node):
-        node.name = self._contract_name
+        node.path = self._module_path
+        node.source_id = self._source_id
         return self._visit_docstring(node)
 
     def visit_FunctionDef(self, node):
@@ -250,7 +251,7 @@ def annotate_python_ast(
     source_code: str,
     modification_offsets: Optional[ModificationOffsets] = None,
     source_id: int = 0,
-    contract_name: Optional[str] = None,
+    module_path: Optional[str] = None,
 ) -> python_ast.AST:
     """
     Annotate and optimize a Python AST in preparation conversion to a Vyper AST.
@@ -270,7 +271,9 @@ def annotate_python_ast(
     """
 
     tokens = asttokens.ASTTokens(source_code, tree=cast(Optional[python_ast.Module], parsed_ast))
-    visitor = AnnotatingVisitor(source_code, modification_offsets, tokens, source_id, contract_name)
+    visitor = AnnotatingVisitor(
+        source_code, modification_offsets, tokens, source_id, module_path=module_path
+    )
     visitor.visit(parsed_ast)
 
     return parsed_ast

vyper/ast/nodes.py

@@ -589,7 +589,8 @@ def __contains__(self, obj):
 
 
 class Module(TopLevel):
-    __slots__ = ()
+    # metadata
+    __slots__ = ("path", "source_id")
 
     def replace_in_tree(self, old_node: VyperNode, new_node: VyperNode) -> None:
         """

vyper/ast/utils.py

@@ -15,7 +15,7 @@ def parse_to_ast(*args: Any, **kwargs: Any) -> vy_ast.Module:
 def parse_to_ast_with_settings(
     source_code: str,
     source_id: int = 0,
-    contract_name: Optional[str] = None,
+    module_path: Optional[str] = None,
     add_fn_node: Optional[str] = None,
 ) -> tuple[Settings, vy_ast.Module]:
     """
@@ -53,7 +53,8 @@ def parse_to_ast_with_settings(
         fn_node.body = py_ast.body
         fn_node.args = python_ast.arguments(defaults=[])
         py_ast.body = [fn_node]
-    annotate_python_ast(py_ast, source_code, class_types, source_id, contract_name)
+
+    annotate_python_ast(py_ast, source_code, class_types, source_id, module_path=module_path)
 
     # Convert to Vyper AST.
     module = vy_ast.get_node(py_ast)

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, module_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

@@ -49,7 +49,8 @@
     TupleT,
 )
 from vyper.semantics.types.bytestrings import _BytestringT
+from vyper.semantics.types.function import ContractFunctionT, MemberFunctionT
 from vyper.semantics.types.shortcuts import BYTES32_T, UINT256_T
 from vyper.utils import (
     DECIMAL_DIVISOR,
     bytes_to_int,
@@ -662,39 +663,39 @@
             if function_name in DISPATCH_TABLE:
                 return DISPATCH_TABLE[function_name].build_IR(self.expr, self.context)
 
-            # Struct constructors do not need `self` prefix.
-            elif isinstance(self.expr._metadata["type"], StructT):
-                args = self.expr.args
-                if len(args) == 1 and isinstance(args[0], vy_ast.Dict):
-                    return Expr.struct_literals(args[0], self.context, self.expr._metadata["type"])
+        func_type = self.expr.func._metadata["type"]
+        return_type = self.expr._metadata["type"]
 
-            # Interface assignment. Bar(<address>).
-            elif isinstance(self.expr._metadata["type"], InterfaceT):
-                (arg0,) = self.expr.args
-                arg_ir = Expr(arg0, self.context).ir_node
+        # Struct constructors do not need `self` prefix.
+        if isinstance(return_type, StructT):
+            args = self.expr.args
+            if len(args) == 1 and isinstance(args[0], vy_ast.Dict):
+                return Expr.struct_literals(args[0], self.context, self.expr._metadata["type"])
 
-                assert arg_ir.typ == AddressT()
-                arg_ir.typ = self.expr._metadata["type"]
+        # Interface assignment. Bar(<address>).
+        if isinstance(return_type, InterfaceT):
+            (arg0,) = self.expr.args
+            arg_ir = Expr(arg0, self.context).ir_node
 
-                return arg_ir
+            assert arg_ir.typ == AddressT()
+            arg_ir.typ = self.expr._metadata["type"]
 
-        elif isinstance(self.expr.func, vy_ast.Attribute) and self.expr.func.attr == "pop":
+            return arg_ir
+
+        if isinstance(func_type, MemberFunctionT) and self.expr.func.attr == "pop":
             # TODO consider moving this to builtins
             darray = Expr(self.expr.func.value, self.context).ir_node
             assert len(self.expr.args) == 0
             assert isinstance(darray.typ, DArrayT)
             return pop_dyn_array(darray, return_popped_item=True)
 
-        elif (
-            # TODO use expr.func.type.is_internal once
-            # 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"
-        ):
-            return self_call.ir_for_self_call(self.expr, self.context)
-        else:
-            return external_call.ir_for_external_call(self.expr, self.context)
+        if isinstance(func_type, ContractFunctionT):
+            if self.expr.func._metadata["type"].is_internal:
+                return self_call.ir_for_self_call(self.expr, self.context)
+            else:
+                return external_call.ir_for_external_call(self.expr, self.context)
+
+        raise CompilerPanic("unreachable", self.expr)
 
     def parse_List(self):
         typ = self.expr._metadata["type"]

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,