use initialized/used modules instead of analyzing functions

charles-cooper · charles-cooper · commit 0747a5c717c4 · 2024-02-24T12:45:57.000-05:00
diff --git a/vyper/semantics/analysis/module.py b/vyper/semantics/analysis/module.py
@@ -75,12 +75,14 @@ def validate_module_semantics_r(
 
     with namespace.enter_scope(), import_graph.enter_path(module_ast):
         analyzer = ModuleAnalyzer(module_ast, input_bundle, namespace, import_graph, is_interface)
-        analyzer.analyze()
+        analyzer.analyze_module_body()
 
         _analyze_call_graph(module_ast)
         generate_public_variable_getters(module_ast)
 
-        ret = ModuleT(module_ast)
+        # ModuleT generates the interface; for this we should have
+        # public variable getters already generated.
+        ret = ModuleT(module_ast)  # note: validates unique method ids
         module_ast._metadata["type"] = ret
 
         # if this is an interface, the function is already validated
@@ -145,7 +147,7 @@ def _compute_reachable_set(fn_t: ContractFunctionT, path: list[ContractFunctionT
         _compute_reachable_set(g, path=path)
 
         g_reachable = g.reachable_internal_functions
-        assert fn_t not in g_reachable # sanity check
+        assert fn_t not in g_reachable  # sanity check
         fn_t.reachable_internal_functions.update(g_reachable)
 
         fn_t.reachable_internal_functions.add(g)
@@ -184,10 +186,7 @@ def __init__(
         if not hasattr(self.input_bundle._cache, "_ast_of"):
             self.input_bundle._cache._ast_of: dict[int, vy_ast.Module] = {}  # type: ignore
 
-    def analyze(self) -> ModuleT:
-        # generate a `ModuleT` from the top-level node
-        # note: also validates unique method ids
-
+    def analyze_module_body(self):
         assert "type" not in self.ast._metadata
 
         self._to_visit = self.ast.body.copy()
diff --git a/vyper/semantics/types/function.py b/vyper/semantics/types/function.py
@@ -30,7 +30,7 @@
     validate_expected_type,
 )
 from vyper.semantics.data_locations import DataLocation
-from vyper.semantics.types.base import KwargSettings, VyperType, is_type_t
+from vyper.semantics.types.base import KwargSettings, VyperType
 from vyper.semantics.types.primitives import BoolT
 from vyper.semantics.types.shortcuts import UINT256_T
 from vyper.semantics.types.subscriptable import TupleT
@@ -462,9 +462,6 @@ def getter_from_VariableDecl(cls, node: vy_ast.VariableDecl) -> "ContractFunctio
             ast_def=node,
         )
 
-    def get_used_events(self):  # -> OrderedSet[EventT]:
-        pass
-
     @property
     # convenience property for compare_signature, as it would
     # appear in a public interface
diff --git a/vyper/semantics/types/module.py b/vyper/semantics/types/module.py
@@ -9,24 +9,22 @@
     NamespaceCollision,
     StructureException,
     UnfoldableNode,
-    VyperException,
 )
 from vyper.semantics.analysis.base import Modifiability
 from vyper.semantics.analysis.utils import (
     check_modifiability,
-    get_exact_type_from_node,
     validate_expected_type,
     validate_unique_method_ids,
 )
-from vyper.utils import OrderedSet
 from vyper.semantics.data_locations import DataLocation
-from vyper.semantics.types.base import TYPE_T, VyperType, is_type_t
+from vyper.semantics.types.base import TYPE_T, VyperType
 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.utils import OrderedSet
 
 if TYPE_CHECKING:
-    from vyper.semantics.analysis.base import ModuleInfo
+    from vyper.semantics.analysis.base import InitializesInfo, ModuleInfo
 
 
 class InterfaceT(_UserType):
@@ -222,7 +220,7 @@ def from_ModuleT(cls, module_t: "ModuleT") -> "InterfaceT":
         if (fn_t := module_t.init_function) is not None:
             funcs.append((fn_t.name, fn_t))
 
-        events = [(event_t.name, event_t) for event_t in module_t.used_events]
+        events = [(event_t.name, event_t) for event_t in module_t.exported_events]
 
         # these are accessible via import, but they do not show up
         # in the ABI json
@@ -282,16 +280,16 @@ def __init__(self, module: vy_ast.Module, name: Optional[str] = None):
 
         for e in self.event_defs:
             # add the type of the event so it can be used in call position
-            self.add_member(e.name, TYPE_T(e._metadata["event_type"]))  # type: ignore
+            self.add_member(e.name, TYPE_T(e._metadata["event_type"]))
 
         for s in self.struct_defs:
             # add the type of the struct so it can be used in call position
-            self.add_member(s.name, TYPE_T(s._metadata["struct_type"]))  # type: ignore
-            self._helper.add_member(s.name, TYPE_T(s._metadata["struct_type"]))  # type: ignore
+            self.add_member(s.name, TYPE_T(s._metadata["struct_type"]))
+            self._helper.add_member(s.name, TYPE_T(s._metadata["struct_type"]))
 
         for i in self.interface_defs:
             # add the type of the interface so it can be used in call position
-            self.add_member(i.name, TYPE_T(i._metadata["interface_type"]))  # type: ignore
+            self.add_member(i.name, TYPE_T(i._metadata["interface_type"]))
 
         for v in self.variable_decls:
             self.add_member(v.target.id, v.target._metadata["varinfo"])
@@ -389,7 +387,7 @@ def exports_decls(self):
         return self._module.get_children(vy_ast.ExportsDecl)
 
     @cached_property
-    def used_modules(self):
+    def used_modules(self) -> list["ModuleInfo"]:
         # modules which are written to
         ret = []
         for node in self.uses_decls:
@@ -398,7 +396,7 @@ def used_modules(self):
         return ret
 
     @property
-    def initialized_modules(self):
+    def initialized_modules(self) -> list["InitializesInfo"]:
         # modules which are initialized to
         ret = []
         for node in self.initializes_decls:
@@ -440,31 +438,16 @@ def functions(self):
         return {f.name: f._metadata["func_type"] for f in self.function_defs}
 
     @cached_property
-    # it would be nice to rely on the function analyzer to do this analysis,
-    # but we don't have the result of function analysis at the time we need to
-    # construct `self.interface`.
-    def used_events(self) -> OrderedSet[EventT]:
+    def exported_events(self) -> OrderedSet[EventT]:
         ret: OrderedSet[EventT] = OrderedSet()
 
-        reachable = OrderedSet()
-        if self.init_function is not None:
-            reachable.add(self.init_function)
-            reachable.update(self.init_function.reachable_internal_functions)
-        for fn_t in self.exposed_functions:
-            reachable.add(fn_t)
-            reachable.update(fn_t.reachable_internal_functions)
-
-        for fn_t in reachable:
-            fn_ast = fn_t.decl_node
-            assert isinstance(fn_ast, vy_ast.FunctionDef)
-
-            for node in fn_ast.get_descendants(vy_ast.Log):
-                call_t = get_exact_type_from_node(node.value.func)
-                if not is_type_t(call_t, EventT):
-                    # this is an error, but it will be handled later
-                    continue
-
-                ret.add(call_t.typedef)
+        for module_info in self.used_modules:
+            ret.update(module_info.module_t.exported_events)
+
+        for info in self.initialized_modules:
+            ret.update(info.module_info.module_t.exported_events)
+
+        ret.update([n._metadata["event_type"] for n in self.event_defs])
 
         return ret
 
