Make dead code indexing use a Model to index modules

lib/spoom/deadcode/index.rb

@@ -51,6 +51,15 @@ def finalize!(plugins: [])
               )
               define(definition)
               plugins.each { |plugin| plugin.internal_on_define_class(symbol_def, definition) }
+            when Model::Module
+              definition = Definition.new(
+                kind: Definition::Kind::Module,
+                name: symbol.name,
+                full_name: symbol.full_name,
+                location: symbol_def.location,
+              )
+              define(definition)
+              plugins.each { |plugin| plugin.internal_on_define_module(symbol_def, definition) }
             end
           end
         end

lib/spoom/deadcode/indexer.rb

@@ -238,16 +238,13 @@ def visit_module_node(node)
           @names_nesting.clear
           @names_nesting << full_name
 
-          define_module(T.must(constant_path.split("::").last), full_name, node)
-
           visit(node.body)
 
           # Restore the name nesting once we finished visited the class
           @names_nesting.clear
           @names_nesting = old_nesting
         else
           @names_nesting << constant_path
-          define_module(T.must(constant_path.split("::").last), @names_nesting.join("::"), node)
 
           # We do not call `super` here because we don't want to visit the `constant` again
           visit(node.body)
@@ -372,18 +369,6 @@ def define_method(name, full_name, node)
         @plugins.each { |plugin| plugin.internal_on_define_method(self, definition) }
       end
 
-      sig { params(name: String, full_name: String, node: Prism::Node).void }
-      def define_module(name, full_name, node)
-        definition = Definition.new(
-          kind: Definition::Kind::Module,
-          name: name,
-          full_name: full_name,
-          location: node_location(node),
-        )
-        @index.define(definition)
-        @plugins.each { |plugin| plugin.internal_on_define_module(self, definition) }
-      end
-
       # Reference indexing
 
       sig { params(name: String, node: Prism::Node).void }

lib/spoom/deadcode/plugins/base.rb

@@ -243,22 +243,22 @@ def internal_on_define_method(indexer, definition)
         #
         # ~~~rb
         # class MyPlugin < Spoom::Deadcode::Plugins::Base
-        #   def on_define_module(indexer, definition)
-        #     definition.ignored! if definition.name == "Foo"
+        #   def on_define_module(symbol_def, definition)
+        #     definition.ignored! if symbol_def.name == "Foo"
         #   end
         # end
         # ~~~
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def on_define_module(indexer, definition)
+        sig { params(symbol_def: Model::Module, definition: Definition).void }
+        def on_define_module(symbol_def, definition)
           # no-op
         end
 
         # Do not override this method, use `on_define_module` instead.
-        sig { params(indexer: Indexer, definition: Definition).void }
-        def internal_on_define_module(indexer, definition)
-          definition.ignored! if ignored_module_name?(definition.name)
+        sig { params(symbol_def: Model::Module, definition: Definition).void }
+        def internal_on_define_module(symbol_def, definition)
+          definition.ignored! if ignored_module_name?(symbol_def.name)
 
-          on_define_module(indexer, definition)
+          on_define_module(symbol_def, definition)
         end
 
         # Called when a send is being processed

lib/spoom/deadcode/plugins/namespaces.rb

@@ -9,22 +9,19 @@ class Namespaces < Base
 
         sig { override.params(symbol_def: Model::Class, definition: Definition).void }
         def on_define_class(symbol_def, definition)
-          definition.ignored! unless symbol_def.children.empty?
+          definition.ignored! if used_as_namespace?(symbol_def)
         end
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_module(indexer, definition)
-          definition.ignored! if used_as_namespace?(indexer)
+        sig { override.params(symbol_def: Model::Module, definition: Definition).void }
+        def on_define_module(symbol_def, definition)
+          definition.ignored! if used_as_namespace?(symbol_def)
         end
 
         private
 
-        sig { params(indexer: Indexer).returns(T::Boolean) }
-        def used_as_namespace?(indexer)
-          node = indexer.current_node
-          return false unless node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
-
-          !!node.body
+        sig { params(symbol_def: Model::Namespace).returns(T::Boolean) }
+        def used_as_namespace?(symbol_def)
+          symbol_def.children.any?
         end
       end
     end

lib/spoom/deadcode/plugins/rails.rb

@@ -11,19 +11,19 @@ class Rails < Base
 
         sig { override.params(symbol_def: Model::Class, definition: Definition).void }
         def on_define_class(symbol_def, definition)
-          definition.ignored! if symbol_def.location.file.match?(%r{app/helpers/.*\.rb$})
+          definition.ignored! if file_is_helper?(symbol_def)
         end
 
-        sig { override.params(indexer: Indexer, definition: Definition).void }
-        def on_define_module(indexer, definition)
-          definition.ignored! if file_is_helper?(indexer)
+        sig { override.params(symbol_def: Model::Module, definition: Definition).void }
+        def on_define_module(symbol_def, definition)
+          definition.ignored! if file_is_helper?(symbol_def)
         end
 
         private
 
-        sig { params(indexer: Indexer).returns(T::Boolean) }
-        def file_is_helper?(indexer)
-          indexer.path.match?(%r{app/helpers/.*\.rb$})
+        sig { params(symbol_def: Model::Namespace).returns(T::Boolean) }
+        def file_is_helper?(symbol_def)
+          symbol_def.location.file.match?(%r{app/helpers/.*\.rb$})
         end
       end
     end

test/spoom/deadcode/plugins/base_test.rb

@@ -82,8 +82,8 @@ def method2; end
 
         def test_on_define_module
           plugin = Class.new(Base) do
-            def on_define_module(indexer, definition)
-              definition.ignored! if definition.name == "Module1"
+            def on_define_module(symbol_def, definition)
+              definition.ignored! if symbol_def.name == "Module1"
             end
           end