feat[lang]: singleton modules with ownership hierarchy

vyper/ast/nodes.py

@@ -83,8 +83,20 @@
             if ast_struct["value"] is not None:
                 _raise_syntax_exc("`implements` cannot have a value assigned", ast_struct)
             ast_struct["ast_type"] = "ImplementsDecl"
+
+        # Replace "uses:" `AnnAssign` nodes with `UsesDecl`
+        elif getattr(ast_struct["target"], "id", None) == "uses":
+            if ast_struct["value"] is not None:
+                _raise_syntax_exc("`uses` cannot have a value assigned", ast_struct)
+            ast_struct["ast_type"] = "UsesDecl"
+
+        # Replace "initializes:" `AnnAssign` nodes with `InitializesDecl`
+        elif getattr(ast_struct["target"], "id", None) == "initializes":
+            if ast_struct["value"] is not None:
+                _raise_syntax_exc("`initializes` cannot have a value assigned", ast_struct)
+            ast_struct["ast_type"] = "InitializesDecl"
+
         # Replace state and local variable declarations `AnnAssign` with `VariableDecl`
-        # Parent node is required for context to determine whether replacement should happen.
         else:
             ast_struct["ast_type"] = "VariableDecl"
 
@@ -718,6 +730,19 @@
     __slots__ = ("value",)
 
 
+class NamedExpr(Stmt):
+    __slots__ = ("target", "value")
+
+    def validate(self):
+        # module[dep1 := dep2]
+
+        # XXX: better error messages
+        if not isinstance(self.target, Name):
+            raise StructureException("not a Name")
+
+        if not isinstance(self.value, Name):
+            raise StructureException("not a Name")
+
 class Log(Stmt):
     __slots__ = ("value",)
 
@@ -1357,24 +1382,80 @@
     """
     An `implements` declaration.
 
-    Excludes `simple` and `value` attributes from Python `AnnAssign` node.
-
     Attributes
     ----------
-    target : Name
-        Name node for the `implements` keyword
     annotation : Name
         Name node for the interface to be implemented
     """
 
-    __slots__ = ("target", "annotation")
+    __slots__ = ("annotation",)
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         if not isinstance(self.annotation, (Name, Attribute)):
             raise StructureException("invalid implements", self.annotation)
 
+class UsesDecl(Stmt):
+    """
+    A `uses` declaration.
+
+    Attributes
+    ----------
+    annotation : Name | Attribute | Tuple
+        The module(s) which this uses
+    """
+    __slots__ = ("annotation",)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if isinstance(self.annotation, Tuple):
+            items = self.annotation.elements
+        else:
+            items = (self.annotation,)
+
+        for item in items:
+            if not isinstance(item, (Name, Attribute)):
+                raise StructureException("invalid uses", item)
+
+class InitializesDecl(Stmt):
+    """
+    An `initializes` declaration.
+
+    Attributes
+    ----------
+    annotation : Name | Attribute | Subscript
+        An imported module which this module initializes
+    """
+    __slots__ = ("annotation",)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        module_ref = self.annotation
+        if isinstance(module_ref, Subscript):
+            module_ref = module_ref.value
+
+            index = self.annotation.slice.value
+
+            if isinstance(index, Tuple):
+                dependencies = dependencies.elements
+            else:
+                dependencies = (index,)
+
+            for item in dependencies:
+                if not isinstance(item, NamedExpr):
+                    print(type(item))
+                    raise StructureException("invalid dependency (hint: should be [dependency := dependency]", item)
+                if not isinstance(item.target, (Name, Attribute)):
+                    raise StructureException("invalid module", item.target)
+                if not isinstance(item.value, (Name, Attribute)):
+                    raise StructureException("invalid module", item.target)
+
+        if not isinstance(module_ref, (Name, Attribute)):
+            raise StructureException("invalid module", module_ref)
+
 
 class If(Stmt):
     __slots__ = ("test", "body", "orelse")

vyper/ast/parse.py

@@ -347,7 +347,9 @@ def visit_Subscript(self, node):
 
         Starting from python 3.9, the `Index` node type has been deprecated,
         and made impossible to instantiate via regular means. Here we do awful
-        hacky black magic to create an `Index` node. We need our own parser.
+        hacky black magic to create an `Index` node.
+
+        TODO: remove Index ast nodes since we require python>=3.10 now - CMC 2024-01-13
         """
         self.generic_visit(node)
 

vyper/codegen/expr.py

@@ -703,7 +703,7 @@ def parse_Call(self):
             return pop_dyn_array(darray, return_popped_item=True)
 
         if isinstance(func_type, ContractFunctionT):
-            if func_type.is_internal:
+            if func_type.is_internal or func_type.is_constructor:
                 return self_call.ir_for_self_call(self.expr, self.context)
             else:
                 return external_call.ir_for_external_call(self.expr, self.context)

vyper/codegen/function_definitions/common.py

@@ -65,7 +65,13 @@ def external_function_base_entry_label(self) -> str:
         return self.ir_identifier + "_common"
 
     def internal_function_label(self, is_ctor_context: bool = False) -> str:
-        assert self.func_t.is_internal, "uh oh, should be internal"
+        f = self.func_t
+        assert f.is_internal or f.is_constructor, "uh oh, should be internal"
+
+        if f.is_constructor:
+            # sanity check - imported init functions only callable from main init
+            assert is_ctor_context
+
         suffix = "_deploy" if is_ctor_context else "_runtime"
         return self.ir_identifier + suffix
 
@@ -140,7 +146,7 @@ def generate_ir_for_function(
         is_ctor_context=is_ctor_context,
     )
 
-    if func_t.is_internal:
+    if func_t.is_internal or func_t.is_constructor:
         ret: FuncIR = InternalFuncIR(generate_ir_for_internal_function(code, func_t, context))
         func_t._ir_info.gas_estimate = ret.func_ir.gas  # type: ignore
     else:
@@ -163,7 +169,7 @@ def generate_ir_for_function(
     else:
         assert frame_info == func_t._ir_info.frame_info
 
-    if not func_t.is_internal:
+    if func_t.is_external:
         # adjust gas estimate to include cost of mem expansion
         # frame_size of external function includes all private functions called
         # (note: internal functions do not need to adjust gas estimate since

vyper/codegen/module.py

@@ -424,12 +424,13 @@ def _selector_section_linear(external_functions, module_ctx):
 
 # take a ModuleT, and generate the runtime and deploy IR
 def generate_ir_for_module(module_ctx: ModuleT) -> tuple[IRnode, IRnode]:
+    # XXX: rename `module_ctx` to `compilation_target`
     # order functions so that each function comes after all of its callees
     function_defs = _topsort(module_ctx.function_defs)
     reachable = _globally_reachable_functions(module_ctx.function_defs)
 
     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)
+    init_function = next((f for f in module_ctx.function_defs if _is_constructor(f)), None)
 
     internal_functions = [f for f in runtime_functions if _is_internal(f)]
 
@@ -475,18 +476,15 @@ def generate_ir_for_module(module_ctx: ModuleT) -> tuple[IRnode, IRnode]:
 
     deploy_code: List[Any] = ["seq"]
     immutables_len = module_ctx.immutable_section_bytes
-    if init_function:
+    if init_function is not None:
         # cleanly rerun codegen for internal functions with `is_ctor_ctx=True`
         init_func_t = init_function._metadata["func_type"]
         ctor_internal_func_irs = []
-        internal_functions = [f for f in runtime_functions if _is_internal(f)]
-        for f in internal_functions:
-            func_t = f._metadata["func_type"]
-            if func_t not in init_func_t.reachable_internal_functions:
-                # unreachable code, delete it
-                continue
-
-            func_ir = _ir_for_internal_function(f, module_ctx, is_ctor_context=True)
+
+        reachable_from_ctor = init_func_t.reachable_internal_functions
+        for func_t in reachable_from_ctor:
+            fn_ast = func_t.ast_def
+            func_ir = _ir_for_internal_function(fn_ast, module_ctx, is_ctor_context=True)
             ctor_internal_func_irs.append(func_ir)
 
         # generate init_func_ir after callees to ensure they have analyzed

vyper/codegen/stmt.py

@@ -145,7 +145,7 @@ def parse_Call(self):
                 return pop_dyn_array(darray, return_popped_item=False)
 
         if isinstance(func_type, ContractFunctionT):
-            if func_type.is_internal:
+            if func_type.is_internal or func_type.is_constructor:
                 return self_call.ir_for_self_call(self.stmt, self.context)
             else:
                 return external_call.ir_for_external_call(self.stmt, self.context)

vyper/semantics/analysis/base.py

@@ -46,14 +46,14 @@ def values(cls) -> List[str]:
     # Comparison operations
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
-            raise CompilerPanic("Can only compare like types.")
+            raise CompilerPanic("bad comparison")
         return self is other
 
     # Python normally does __ne__(other) ==> not self.__eq__(other)
 
     def __lt__(self, other: object) -> bool:
         if not isinstance(other, self.__class__):
-            raise CompilerPanic("Can only compare like types.")
+            raise CompilerPanic("bad comparison")
         options = self.__class__.options()
         return options.index(self) < options.index(other)  # type: ignore
 
@@ -68,9 +68,16 @@ def __ge__(self, other: object) -> bool:
 
 
 class FunctionVisibility(_StringEnum):
-    # TODO: these can just be enum.auto() right?
-    EXTERNAL = _StringEnum.auto()
-    INTERNAL = _StringEnum.auto()
+    EXTERNAL = enum.auto()
+    INTERNAL = enum.auto()
+    CONSTRUCTOR = enum.auto()
+
+    @classmethod
+    def is_valid_value(cls, value: str) -> bool:
+        # make CONSTRUCTOR visibility not available to the user
+        # (although as a design note - maybe `@constructor` should
+        # indeed be available)
+        return super().is_valid_value(value) and value != "constructor"
 
 
 class StateMutability(_StringEnum):

vyper/semantics/analysis/module.py

@@ -49,6 +49,11 @@ def validate_semantics_r(
     Analyze a Vyper module AST node, add all module-level objects to the
     namespace, type-check/validate semantics and annotate with type and analysis info
     """
+    if "type" in module_ast._metadata:
+        # we don't need to analyse again, skip out
+        assert isinstance(module_ast._metadata["type"], ModuleT)
+        return module_ast._metadata["type"]
+
     validate_literal_nodes(module_ast)
 
     # validate semantics and annotate AST with type/semantics information
@@ -121,11 +126,8 @@ def __init__(
     def analyze(self) -> ModuleT:
         # generate a `ModuleT` from the top-level node
         # note: also validates unique method ids
-        if "type" in self.ast._metadata:
-            assert isinstance(self.ast._metadata["type"], ModuleT)
-            # we don't need to analyse again, skip out
-            self.module_t = self.ast._metadata["type"]
-            return self.module_t
+
+        assert "type" not in self.ast._metadata
 
         to_visit = self.ast.body.copy()
 
@@ -195,7 +197,8 @@ def analyze_call_graph(self):
                     # we just want to be able to construct the call graph.
                     continue
 
-                if isinstance(call_t, ContractFunctionT) and call_t.is_internal:
+                if isinstance(call_t, ContractFunctionT) and (call_t.is_internal or call_t.is_constructor):
+
                     fn_t.called_functions.add(call_t)
 
         for func in function_defs:
@@ -222,6 +225,14 @@ def visit_ImplementsDecl(self, node):
 
         type_.validate_implements(node)
 
+    def visit_UsesDecl(self, node):
+        # XXX: implement
+        pass
+
+    def visit_InitializesDecl(self, node):
+        # XXX: implement
+        pass
+
     def visit_VariableDecl(self, node):
         name = node.get("target.id")
         if name is None:

vyper/semantics/types/function.py

@@ -272,6 +272,8 @@ def from_vyi(cls, funcdef: vy_ast.FunctionDef) -> "ContractFunctionT":
                 "function body in an interface can only be ...!", funcdef
             )
 
+        assert function_visibility is not None  # mypy hint
+
         return cls(
             funcdef.name,
             positional_args,
@@ -315,13 +317,15 @@ def from_FunctionDef(cls, funcdef: vy_ast.FunctionDef) -> "ContractFunctionT":
                 )
 
         if funcdef.name == "__init__":
-            if (
-                state_mutability in (StateMutability.PURE, StateMutability.VIEW)
-                or function_visibility == FunctionVisibility.INTERNAL
-            ):
+            if state_mutability in (StateMutability.PURE, StateMutability.VIEW):
+                raise FunctionDeclarationException(
+                    "Constructor cannot be marked as `@pure` or `@view`", funcdef
+                )
+            if function_visibility is not None:
                 raise FunctionDeclarationException(
-                    "Constructor cannot be marked as `@pure`, `@view` or `@internal`", funcdef
+                    "Constructor cannot be marked as `@internal` or `@external`", funcdef
                 )
+            function_visibility = FunctionVisibility.CONSTRUCTOR
             if return_type is not None:
                 raise FunctionDeclarationException(
                     "Constructor may not have a return type", funcdef.returns
@@ -333,6 +337,9 @@ def from_FunctionDef(cls, funcdef: vy_ast.FunctionDef) -> "ContractFunctionT":
                     "Constructor may not use default arguments", funcdef.args.defaults[0]
                 )
 
+        # sanity check
+        assert function_visibility is not None
+
         return cls(
             funcdef.name,
             positional_args,
@@ -456,6 +463,10 @@ def is_external(self) -> bool:
     def is_internal(self) -> bool:
         return self.visibility == FunctionVisibility.INTERNAL
 
+    @property
+    def is_constructor(self) -> bool:
+        return self.visibility == FunctionVisibility.CONSTRUCTOR
+
     @property
     def is_mutable(self) -> bool:
         return self.mutability > StateMutability.VIEW
@@ -464,10 +475,6 @@ def is_mutable(self) -> bool:
     def is_payable(self) -> bool:
         return self.mutability == StateMutability.PAYABLE
 
-    @property
-    def is_constructor(self) -> bool:
-        return self.name == "__init__"
-
     @property
     def is_fallback(self) -> bool:
         return self.name == "__default__"
@@ -601,7 +608,7 @@ def _parse_return_type(funcdef: vy_ast.FunctionDef) -> Optional[VyperType]:
 
 def _parse_decorators(
     funcdef: vy_ast.FunctionDef,
-) -> tuple[FunctionVisibility, StateMutability, Optional[str]]:
+) -> tuple[Optional[FunctionVisibility], StateMutability, Optional[str]]:
     function_visibility = None
     state_mutability = None
     nonreentrant_key = None
@@ -656,7 +663,7 @@ def _parse_decorators(
         else:
             raise StructureException("Bad decorator syntax", decorator)
 
-    if function_visibility is None:
+    if function_visibility is None and funcdef.name != "__init__":
         raise FunctionDeclarationException(
             f"Visibility must be set to one of: {', '.join(FunctionVisibility.values())}", funcdef
         )