Add support for class_methods do blocks within concerns

lib/ruby_lsp/ruby_lsp_rails/indexing_enhancement.rb

@@ -20,6 +20,20 @@ def on_call_node_enter(call_node)
           handle_concern_extend(owner, call_node)
         when :has_one, :has_many, :belongs_to, :has_and_belongs_to_many
           handle_association(owner, call_node)
+        # for `class_methods do` blocks within concerns
+        when :class_methods
+          handle_class_methods(owner, call_node)
+        end
+      end
+
+      sig do
+        override.params(
+          call_node: Prism::CallNode,
+        ).void
+      end
+      def on_call_node_leave(call_node)
+        if call_node.name == :class_methods && call_node.block
+          @listener.pop_namespace_stack
         end
       end
 
@@ -83,6 +97,13 @@ def handle_concern_extend(owner, call_node)
           # Do nothing
         end
       end
+
+      sig { params(owner: RubyIndexer::Entry::Namespace, call_node: Prism::CallNode).void }
+      def handle_class_methods(owner, call_node)
+        return unless call_node.block
+
+        @listener.add_module("ClassMethods", call_node.location, call_node.location)
+      end
     end
   end
 end

test/dummy/app/models/concerns/verifiable.rb

@@ -13,4 +13,10 @@ def all_verified
       all.select(&:verified?)
     end
   end
+
+  class_methods do
+    def all_unverified
+      all.reject(&:verified?)
+    end
+  end
 end

test/ruby_lsp_rails/indexing_enhancement_test.rb

@@ -8,7 +8,7 @@ module Rails
     class IndexingEnhancementTest < ActiveSupport::TestCase
       class << self
         # For these tests, it's convenient to have the index fully populated with Rails information, but we don't have
-        # to reindex on every single example or that will be too slow
+        # to re-index on every single example or that will be too slow
         def populated_index
           @index ||= begin
             index = RubyIndexer::Index.new
@@ -20,22 +20,77 @@ def populated_index
 
       def setup
         @index = self.class.populated_index
+        @indexable_path = RubyIndexer::IndexablePath.new(nil, "/fake.rb")
+      end
+
+      def teardown
+        # Prevent state leaking between tests
+        @index.delete(@indexable_path)
+        @index.instance_variable_set(:@ancestors, {})
       end
 
       test "ClassMethods module inside concerns are automatically extended" do
-        @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
-          class Post < ActiveRecord::Base
+        @index.index_single(@indexable_path, <<~RUBY)
+          module Verifiable
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+              def all_verified; end
+            end
+          end
+
+          class Post
+            include Verifiable
           end
         RUBY
 
         ancestors = @index.linearized_ancestors_of("Post::<Class:Post>")
-        assert_includes(ancestors, "ActiveRecord::Associations::ClassMethods")
-        assert_includes(ancestors, "ActiveRecord::Store::ClassMethods")
-        assert_includes(ancestors, "ActiveRecord::AttributeMethods::ClassMethods")
+
+        assert_includes(ancestors, "Verifiable::ClassMethods")
+        refute_nil(@index.resolve_method("all_verified", "Post::<Class:Post>"))
+      end
+
+      test "class_methods blocks inside concerns are automatically extended via a ClassMethods module" do
+        @index.index_single(@indexable_path, <<~RUBY)
+          module Verifiable
+            extend ActiveSupport::Concern
+
+            class_methods do
+              def all_verified; end
+            end
+          end
+
+          class Post
+            include Verifiable
+          end
+        RUBY
+
+        ancestors = @index.linearized_ancestors_of("Post::<Class:Post>")
+
+        assert_includes(ancestors, "Verifiable::ClassMethods")
+        refute_nil(@index.resolve_method("all_verified", "Post::<Class:Post>"))
+      end
+
+      test "ignores `class_methods` calls without a block" do
+        @index.index_single(@indexable_path, <<~RUBY)
+          module Verifiable
+            extend ActiveSupport::Concern
+
+            class_methods
+          end
+
+          class Post
+            include Verifiable
+          end
+        RUBY
+
+        ancestors = @index.linearized_ancestors_of("Post::<Class:Post>")
+
+        refute_includes(ancestors, "Verifiable::ClassMethods")
       end
 
       test "associations" do
-        @index.index_single(RubyIndexer::IndexablePath.new(nil, "/fake.rb"), <<~RUBY)
+        @index.index_single(@indexable_path, <<~RUBY)
           class Post < ActiveRecord::Base
             has_one :content
             belongs_to :author