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 @@
         # 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,
@@ -45,28 +45,35 @@
         functions: dict,
         events: dict,
         structs: dict,
+        constants: Optional[dict] = None,
     ) -> None:
         validate_unique_method_ids(list(functions.values()))
 
-        members = functions | events | structs
+        constants = constants if constants else {}
+
+        members = functions | events | structs | 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(constants)
 
         super().__init__(functions)
 
-        self._helper = VyperType(events | structs)
+        self._helper = VyperType(events | structs | constants)
         self._id = _id
         self._helper._id = _id
         self.functions = functions
         self.events = events
         self.structs = structs
+        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, StructT)):
+            return TYPE_T(type_member)
+        return type_member
 
     @property
     def getter_signature(self):
@@ -161,10 +168,12 @@
         function_list: list[tuple[str, ContractFunctionT]],
         event_list: list[tuple[str, EventT]],
         struct_list: list[tuple[str, StructT]],
+        constant_list: Optional[list[tuple[str, VarInfo]]] = None,
     ) -> "InterfaceT":
         functions = {}
         events = {}
         structs = {}
+        constants = {}
 
         seen_items: dict = {}
 
@@ -187,7 +196,12 @@
             _mark_seen(name, struct)
             structs[name] = struct
 
-        return cls(interface_name, decl_node, functions, events, structs)
+        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, constants)
 
     @classmethod
     def from_json_abi(cls, name: str, abi: dict) -> "InterfaceT":
@@ -247,8 +261,12 @@
         # 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)
+        constants = [
+            (node.target.id, node.target._metadata["varinfo"])
+            for node in module_t.variable_decls
+            if node.target._metadata["varinfo"].modifiability is Modifiability.CONSTANT
+        ]
+        return cls._from_lists(module_t._id, module_t.decl_node, funcs, events, structs, constants)
 
     @classmethod
     def from_InterfaceDef(cls, node: vy_ast.InterfaceDef) -> "InterfaceT":