feat[lang]: support flags from imported interfaces

vyper/semantics/analysis/constant_folding.py

@@ -3,6 +3,7 @@
 from vyper.semantics.analysis.base import VarInfo
 from vyper.semantics.analysis.common import VyperNodeVisitorBase
 from vyper.semantics.namespace import get_namespace
+from vyper.semantics.types.module import InterfaceT
 
 
 def constant_fold(module_ast: vy_ast.Module):
@@ -105,12 +106,15 @@ def visit_Attribute(self, node) -> vy_ast.ExprNode:
         # not super type-safe but we don't care. just catch AttributeErrors
         # and move on
         try:
-            module_t = namespace[value.id].module_t
-
+            ns_member = namespace[value.id]
+            module_t = ns_member if isinstance(ns_member, InterfaceT) else ns_member.module_t
             for module_name in path:
                 module_t = module_t.members[module_name].module_t
-
-            varinfo = module_t.get_member(node.attr, node)
+            varinfo = (
+                module_t.get_type_member(node.attr, node)
+                if isinstance(module_t, InterfaceT)
+                else module_t.get_member(node.attr, node)
+            )
 
             return varinfo.decl_node.value.get_folded_value()
         except (VyperException, AttributeError, KeyError):

vyper/semantics/types/module.py

@@ -10,7 +10,7 @@
     StructureException,
     UnfoldableNode,
 )
-from vyper.semantics.analysis.base import Modifiability
+from vyper.semantics.analysis.base import Modifiability, VarInfo
 from vyper.semantics.analysis.utils import (
     check_modifiability,
     get_exact_type_from_node,
@@ -21,7 +21,7 @@
 from vyper.semantics.types.base import TYPE_T, VyperType, is_type_t
 from vyper.semantics.types.function import ContractFunctionT
 from vyper.semantics.types.primitives import AddressT
-from vyper.semantics.types.user import EventT, StructT, _UserType
+from vyper.semantics.types.user import EventT, FlagT, StructT, _UserType
 from vyper.utils import OrderedSet, sha256sum
 
 if TYPE_CHECKING:
@@ -45,28 +45,41 @@
         functions: dict,
         events: dict,
         structs: dict,
+        flags: dict,
+        constants: dict,
     ) -> None:
         validate_unique_method_ids(list(functions.values()))
 
-        members = functions | events | structs
+        public_constants = {
+            k: varinfo for k, varinfo in constants.items() if varinfo.decl_node.is_public
+        }
+
+        members = functions | events | structs | flags | constants
 
         # sanity check: by construction, there should be no duplicates.
-        assert len(members) == len(functions) + len(events) + len(structs)
+        assert len(members) == len(functions) + len(events) + len(structs) + len(flags) + len(
+            constants
+        ) - len(public_constants)
 
         super().__init__(functions)
 
-        self._helper = VyperType(events | structs)
+        self._helper = VyperType(events | structs | flags | constants)
         self._id = _id
         self._helper._id = _id
         self.functions = functions
         self.events = events
         self.structs = structs
+        self.flags = flags
+        self.constants = constants
 
         self.decl_node = decl_node
 
     def get_type_member(self, attr, node):
-        # get an event or struct from this interface
-        return TYPE_T(self._helper.get_member(attr, node))
+        # get an event, struct or constant from this interface
+        type_member = self._helper.get_member(attr, node)
+        if isinstance(type_member, (EventT, FlagT, StructT)):
+            return TYPE_T(type_member)
+        return type_member
 
     @property
     def getter_signature(self):
@@ -159,35 +172,57 @@
         interface_name: str,
         decl_node: Optional[vy_ast.VyperNode],
         function_list: list[tuple[str, ContractFunctionT]],
-        event_list: list[tuple[str, EventT]],
-        struct_list: list[tuple[str, StructT]],
+        event_list: Optional[list[tuple[str, EventT]]] = None,
+        struct_list: Optional[list[tuple[str, StructT]]] = None,
+        flag_list: Optional[list[tuple[str, FlagT]]] = None,
+        constant_list: Optional[list[tuple[str, VarInfo]]] = None,
     ) -> "InterfaceT":
         functions = {}
         events = {}
         structs = {}
+        flags = {}
+        constants = {}
 
         seen_items: dict = {}
 
         def _mark_seen(name, item):
             if name in seen_items:
+                prev = seen_items[name]
+                if (
+                    isinstance(prev, ContractFunctionT)
+                    and isinstance(item, VarInfo)
+                    and item.decl_node.is_public
+                ):
+                    return
                 msg = f"multiple functions or events named '{name}'!"
-                prev_decl = seen_items[name].decl_node
-                raise NamespaceCollision(msg, item.decl_node, prev_decl=prev_decl)
+                raise NamespaceCollision(msg, item.decl_node, prev_decl=prev.decl_node)
             seen_items[name] = item
 
         for name, function in function_list:
             _mark_seen(name, function)
             functions[name] = function
 
-        for name, event in event_list:
-            _mark_seen(name, event)
-            events[name] = event
+        if event_list:
+            for name, event in event_list:
+                _mark_seen(name, event)
+                events[name] = event
+
+        if struct_list:
+            for name, struct in struct_list:
+                _mark_seen(name, struct)
+                structs[name] = struct
+
+        if flag_list:
+            for name, flag in flag_list:
+                _mark_seen(name, flag)
+                flags[name] = flag
 
-        for name, struct in struct_list:
-            _mark_seen(name, struct)
-            structs[name] = struct
+        if constant_list:
+            for name, constant in constant_list:
+                _mark_seen(name, constant)
+                constants[name] = constant
 
-        return cls(interface_name, decl_node, functions, events, structs)
+        return cls(interface_name, decl_node, functions, events, structs, flags, constants)
 
     @classmethod
     def from_json_abi(cls, name: str, abi: dict) -> "InterfaceT":
@@ -214,8 +249,7 @@
         for item in [i for i in abi if i.get("type") == "event"]:
             events.append((item["name"], EventT.from_abi(item)))
 
-        structs: list = []  # no structs in json ABI (as of yet)
-        return cls._from_lists(name, None, functions, events, structs)
+        return cls._from_lists(name, None, functions, events)
 
     @classmethod
     def from_ModuleT(cls, module_t: "ModuleT") -> "InterfaceT":
@@ -247,8 +281,15 @@
         # these are accessible via import, but they do not show up
         # in the ABI json
         structs = [(node.name, node._metadata["struct_type"]) for node in module_t.struct_defs]
-
-        return cls._from_lists(module_t._id, module_t.decl_node, funcs, events, structs)
+        flags = [(node.name, node._metadata["flag_type"]) for node in module_t.flag_defs]
+        constants = [
+            (node.target.id, node.target._metadata["varinfo"])
+            for node in module_t.variable_decls
+            if node.is_constant
+        ]
+        return cls._from_lists(
+            module_t._id, module_t.decl_node, funcs, events, structs, flags, constants
+        )
 
     @classmethod
     def from_InterfaceDef(cls, node: vy_ast.InterfaceDef) -> "InterfaceT":
@@ -265,11 +306,7 @@
                 )
             functions.append((func_ast.name, ContractFunctionT.from_InterfaceDef(func_ast)))
 
-        # no structs or events in InterfaceDefs
-        events: list = []
-        structs: list = []
-
-        return cls._from_lists(node.name, node, functions, events, structs)
+        return cls._from_lists(node.name, node, functions)
 
 
 # Datatype to store all module information.