ruby-lsp 0.26.5 → 0.26.7

data/lib/ruby_indexer/test/method_test.rb

@@ -1,990 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require_relative "test_case"
-
-module RubyIndexer
-  class MethodTest < TestCase
-    def test_method_with_no_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-    end
-
-    def test_conditional_method
-      index(<<~RUBY)
-        class Foo
-          def bar
-          end if condition
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-    end
-
-    def test_method_with_multibyte_characters
-      index(<<~RUBY)
-        class Foo
-          def こんにちは; end
-        end
-      RUBY
-
-      assert_entry("こんにちは", Entry::Method, "/fake/path/foo.rb:1-2:1-16")
-    end
-
-    def test_singleton_method_using_self_receiver
-      index(<<~RUBY)
-        class Foo
-          def self.bar
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      owner = entry.owner
-      assert_equal("Foo::<Class:Foo>", owner&.name)
-      assert_instance_of(Entry::SingletonClass, owner)
-    end
-
-    def test_singleton_method_using_other_receiver_is_not_indexed
-      index(<<~RUBY)
-        class Foo
-          def String.bar
-          end
-        end
-      RUBY
-
-      assert_no_entry("bar")
-    end
-
-    def test_method_under_dynamic_class_or_module
-      index(<<~RUBY)
-        module Foo
-          class self::Bar
-            def bar
-            end
-          end
-        end
-
-        module Bar
-          def bar
-          end
-        end
-      RUBY
-
-      assert_equal(2, @index["bar"]&.length)
-      first_entry = @index["bar"]&.first #: as Entry::Method
-      assert_equal("Foo::self::Bar", first_entry.owner&.name)
-      second_entry = @index["bar"]&.last #: as Entry::Method
-      assert_equal("Bar", second_entry.owner&.name)
-    end
-
-    def test_visibility_tracking
-      index(<<~RUBY)
-        class Foo
-          private def foo
-          end
-
-          def bar; end
-
-          protected
-
-          def baz; end
-        end
-      RUBY
-
-      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:1-10:2-5", visibility: :private)
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:4-2:4-14", visibility: :public)
-      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:8-2:8-14", visibility: :protected)
-    end
-
-    def test_visibility_tracking_with_nested_class_or_modules
-      index(<<~RUBY)
-        class Foo
-          private
-
-          def foo; end
-
-          class Bar
-            def bar; end
-          end
-
-          def baz; end
-        end
-      RUBY
-
-      assert_entry("foo", Entry::Method, "/fake/path/foo.rb:3-2:3-14", visibility: :private)
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:6-4:6-16", visibility: :public)
-      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:9-2:9-14", visibility: :private)
-    end
-
-    def test_visibility_tracking_with_module_function
-      index(<<~RUBY)
-        module Test
-          def foo; end
-          def bar; end
-          module_function :foo, "bar"
-        end
-      RUBY
-
-      ["foo", "bar"].each do |keyword|
-        entries = @index[keyword] #: as Array[Entry::Method]
-        # should receive two entries because module_function creates a singleton method
-        # for the Test module and a private method for classes include the Test module
-        assert_equal(entries.size, 2)
-        first_entry, second_entry = *entries
-        # The first entry points to the location of the module_function call
-        assert_equal("Test", first_entry&.owner&.name)
-        assert_instance_of(Entry::Module, first_entry&.owner)
-        assert_predicate(first_entry, :private?)
-        # The second entry points to the public singleton method
-        assert_equal("Test::<Class:Test>", second_entry&.owner&.name)
-        assert_instance_of(Entry::SingletonClass, second_entry&.owner)
-        assert_equal(:public, second_entry&.visibility)
-      end
-    end
-
-    def test_private_class_method_visibility_tracking_string_symbol_arguments
-      index(<<~RUBY)
-        class Test
-          def self.foo
-          end
-
-          def self.bar
-          end
-
-          private_class_method("foo", :bar)
-
-          def self.baz
-          end
-        end
-      RUBY
-
-      ["foo", "bar"].each do |keyword|
-        entries = @index[keyword] #: as Array[Entry::Method]
-        assert_equal(1, entries.size)
-        entry = entries.first
-        assert_predicate(entry, :private?)
-      end
-
-      entries = @index["baz"] #: as Array[Entry::Method]
-      assert_equal(1, entries.size)
-      entry = entries.first
-      assert_predicate(entry, :public?)
-    end
-
-    def test_private_class_method_visibility_tracking_array_argument
-      index(<<~RUBY)
-        class Test
-          def self.foo
-          end
-
-          def self.bar
-          end
-
-          private_class_method(["foo", :bar])
-
-          def self.baz
-          end
-        end
-      RUBY
-
-      ["foo", "bar"].each do |keyword|
-        entries = @index[keyword] #: as Array[Entry::Method]
-        assert_equal(1, entries.size)
-        entry = entries.first
-        assert_predicate(entry, :private?)
-      end
-
-      entries = @index["baz"] #: as Array[Entry::Method]
-      assert_equal(1, entries.size)
-      entry = entries.first
-      assert_predicate(entry, :public?)
-    end
-
-    def test_private_class_method_visibility_tracking_method_argument
-      index(<<~RUBY)
-        class Test
-          private_class_method def self.foo
-          end
-
-          def self.bar
-          end
-        end
-      RUBY
-
-      entries = @index["foo"] #: as Array[Entry::Method]
-      assert_equal(1, entries.size)
-      entry = entries.first
-      assert_predicate(entry, :private?)
-
-      entries = @index["bar"] #: as Array[Entry::Method]
-      assert_equal(1, entries.size)
-      entry = entries.first
-      assert_predicate(entry, :public?)
-    end
-
-    def test_comments_documentation
-      index(<<~RUBY)
-        # Documentation for Foo
-
-        class Foo
-          # ####################
-          # Documentation for bar
-          # ####################
-          #
-          def bar
-          end
-
-          # test
-
-          # Documentation for baz
-          def baz; end
-          def ban; end
-        end
-      RUBY
-
-      foo = @index["Foo"]&.first #: as !nil
-      assert_equal("Documentation for Foo", foo.comments)
-
-      bar = @index["bar"]&.first #: as !nil
-      assert_equal("####################\nDocumentation for bar\n####################\n", bar.comments)
-
-      baz = @index["baz"]&.first #: as !nil
-      assert_equal("Documentation for baz", baz.comments)
-
-      ban = @index["ban"]&.first #: as !nil
-      assert_empty(ban.comments)
-    end
-
-    def test_method_with_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(a)
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(1, parameters.length)
-      parameter = parameters.first
-      assert_equal(:a, parameter&.name)
-      assert_instance_of(Entry::RequiredParameter, parameter)
-    end
-
-    def test_method_with_destructed_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar((a, (b, )))
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(1, parameters.length)
-      parameter = parameters.first
-      assert_equal(:"(a, (b, ))", parameter&.name)
-      assert_instance_of(Entry::RequiredParameter, parameter)
-    end
-
-    def test_method_with_optional_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(a = 123)
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(1, parameters.length)
-      parameter = parameters.first
-      assert_equal(:a, parameter&.name)
-      assert_instance_of(Entry::OptionalParameter, parameter)
-    end
-
-    def test_method_with_keyword_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(a:, b: 123)
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      a, b = parameters
-
-      assert_equal(:a, a&.name)
-      assert_instance_of(Entry::KeywordParameter, a)
-
-      assert_equal(:b, b&.name)
-      assert_instance_of(Entry::OptionalKeywordParameter, b)
-    end
-
-    def test_method_with_rest_and_keyword_rest_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(*a, **b)
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      a, b = parameters
-
-      assert_equal(:a, a&.name)
-      assert_instance_of(Entry::RestParameter, a)
-
-      assert_equal(:b, b&.name)
-      assert_instance_of(Entry::KeywordRestParameter, b)
-    end
-
-    def test_method_with_post_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(*a, b)
-          end
-
-          def baz(**a, b)
-          end
-
-          def qux(*a, (b, c))
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      a, b = parameters
-
-      assert_equal(:a, a&.name)
-      assert_instance_of(Entry::RestParameter, a)
-
-      assert_equal(:b, b&.name)
-      assert_instance_of(Entry::RequiredParameter, b)
-
-      entry = @index["baz"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      a, b = parameters
-
-      assert_equal(:a, a&.name)
-      assert_instance_of(Entry::KeywordRestParameter, a)
-
-      assert_equal(:b, b&.name)
-      assert_instance_of(Entry::RequiredParameter, b)
-
-      entry = @index["qux"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      _a, second = parameters
-
-      assert_equal(:"(b, c)", second&.name)
-      assert_instance_of(Entry::RequiredParameter, second)
-    end
-
-    def test_method_with_destructured_rest_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar((a, *b))
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(1, parameters.length)
-      param = parameters.first #: as Entry::Parameter
-
-      assert_equal(:"(a, *b)", param.name)
-      assert_instance_of(Entry::RequiredParameter, param)
-    end
-
-    def test_method_with_block_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(&block)
-          end
-
-          def baz(&)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      param = parameters.first #: as Entry::Parameter
-      assert_equal(:block, param.name)
-      assert_instance_of(Entry::BlockParameter, param)
-
-      entry = @index["baz"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(1, parameters.length)
-
-      param = parameters.first #: as Entry::Parameter
-      assert_equal(Entry::BlockParameter::DEFAULT_NAME, param.name)
-      assert_instance_of(Entry::BlockParameter, param)
-    end
-
-    def test_method_with_anonymous_rest_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(*, **)
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      first, second = parameters
-
-      assert_equal(Entry::RestParameter::DEFAULT_NAME, first&.name)
-      assert_instance_of(Entry::RestParameter, first)
-
-      assert_equal(Entry::KeywordRestParameter::DEFAULT_NAME, second&.name)
-      assert_instance_of(Entry::KeywordRestParameter, second)
-    end
-
-    def test_method_with_forbidden_keyword_splat_parameter
-      index(<<~RUBY)
-        class Foo
-          def bar(**nil)
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:2-5")
-      entry = @index["bar"]&.first #: as Entry::Method
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_empty(parameters)
-    end
-
-    def test_methods_with_argument_forwarding
-      index(<<~RUBY)
-        class Foo
-          def bar(...)
-          end
-
-          def baz(a, ...)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      assert_instance_of(Entry::Method, entry, "Expected `bar` to be indexed")
-
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(1, parameters.length)
-      assert_instance_of(Entry::ForwardingParameter, parameters.first)
-
-      entry = @index["baz"]&.first #: as Entry::Method
-      assert_instance_of(Entry::Method, entry, "Expected `baz` to be indexed")
-
-      parameters = entry.signatures.first&.parameters #: as Array[Entry::Parameter]
-      assert_equal(2, parameters.length)
-      assert_instance_of(Entry::RequiredParameter, parameters[0])
-      assert_instance_of(Entry::ForwardingParameter, parameters[1])
-    end
-
-    def test_keeps_track_of_method_owner
-      index(<<~RUBY)
-        class Foo
-          def bar
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      owner_name = entry.owner&.name
-
-      assert_equal("Foo", owner_name)
-    end
-
-    def test_keeps_track_of_attributes
-      index(<<~RUBY)
-        class Foo
-          # Hello there
-          attr_reader :bar, :other
-          attr_writer :baz
-          attr_accessor :qux
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:2-15:2-18")
-      assert_equal("Hello there", @index["bar"]&.first&.comments)
-      assert_entry("other", Entry::Accessor, "/fake/path/foo.rb:2-21:2-26")
-      assert_equal("Hello there", @index["other"]&.first&.comments)
-      assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:3-15:3-18")
-      assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
-      assert_entry("qux=", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
-    end
-
-    def test_ignores_attributes_invoked_on_constant
-      index(<<~RUBY)
-        class Foo
-        end
-
-        Foo.attr_reader :bar
-      RUBY
-
-      assert_no_entry("bar")
-    end
-
-    def test_properly_tracks_multiple_levels_of_nesting
-      index(<<~RUBY)
-        module Foo
-          def first_method; end
-
-          module Bar
-            def second_method; end
-          end
-
-          def third_method; end
-        end
-      RUBY
-
-      entry = @index["first_method"]&.first #: as Entry::Method
-      assert_equal("Foo", entry.owner&.name)
-
-      entry = @index["second_method"]&.first #: as Entry::Method
-      assert_equal("Foo::Bar", entry.owner&.name)
-
-      entry = @index["third_method"]&.first #: as Entry::Method
-      assert_equal("Foo", entry.owner&.name)
-    end
-
-    def test_keeps_track_of_aliases
-      index(<<~RUBY)
-        class Foo
-          alias whatever to_s
-          alias_method :foo, :to_a
-          alias_method "bar", "to_a"
-
-          # These two are not indexed because they are dynamic or incomplete
-          alias_method baz, :to_a
-          alias_method :baz
-        end
-      RUBY
-
-      assert_entry("whatever", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:1-8:1-16")
-      assert_entry("foo", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:2-15:2-19")
-      assert_entry("bar", Entry::UnresolvedMethodAlias, "/fake/path/foo.rb:3-15:3-20")
-      # Foo plus 3 valid aliases
-      assert_equal(4, @index.length - @default_indexed_entries.length)
-    end
-
-    def test_singleton_methods
-      index(<<~RUBY)
-        class Foo
-          def self.bar; end
-
-          class << self
-            def baz; end
-          end
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Method, "/fake/path/foo.rb:1-2:1-19")
-      assert_entry("baz", Entry::Method, "/fake/path/foo.rb:4-4:4-16")
-
-      bar = @index["bar"]&.first #: as Entry::Method
-      baz = @index["baz"]&.first #: as Entry::Method
-
-      assert_instance_of(Entry::SingletonClass, bar.owner)
-      assert_instance_of(Entry::SingletonClass, baz.owner)
-
-      # Regardless of whether the method was added through `self.something` or `class << self`, the owner object must be
-      # the exact same
-      assert_same(bar.owner, baz.owner)
-    end
-
-    def test_name_location_points_to_method_identifier_location
-      index(<<~RUBY)
-        class Foo
-          def bar
-            a = 123
-            a + 456
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      refute_equal(entry.location, entry.name_location)
-
-      name_location = entry.name_location
-      assert_equal(2, name_location.start_line)
-      assert_equal(2, name_location.end_line)
-      assert_equal(6, name_location.start_column)
-      assert_equal(9, name_location.end_column)
-    end
-
-    def test_signature_matches_for_a_method_with_positional_params
-      index(<<~RUBY)
-        class Foo
-          def bar(a, b = 123)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      # Matching calls
-      assert_signature_matches(entry, "bar()")
-      assert_signature_matches(entry, "bar(1)")
-      assert_signature_matches(entry, "bar(1, 2)")
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar(1, ...)")
-      assert_signature_matches(entry, "bar(*a)")
-      assert_signature_matches(entry, "bar(1, *a)")
-      assert_signature_matches(entry, "bar(1, *a, 2)")
-      assert_signature_matches(entry, "bar(*a, 2)")
-      assert_signature_matches(entry, "bar(1, **a)")
-      assert_signature_matches(entry, "bar(1) {}")
-      # This call is impossible to analyze statically because it depends on whether there are elements inside `a` or
-      # not. If there's nothing, the call will fail. But if there's anything inside, the hash will become the first
-      # positional argument
-      assert_signature_matches(entry, "bar(**a)")
-
-      # Non matching calls
-
-      refute_signature_matches(entry, "bar(1, 2, 3)")
-      refute_signature_matches(entry, "bar(1, b: 2)")
-      refute_signature_matches(entry, "bar(1, 2, c: 3)")
-    end
-
-    def test_signature_matches_for_a_method_with_argument_forwarding
-      index(<<~RUBY)
-        class Foo
-          def bar(...)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      # All calls match a forwarding parameter
-      assert_signature_matches(entry, "bar(1)")
-      assert_signature_matches(entry, "bar(1, 2)")
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar(1, ...)")
-      assert_signature_matches(entry, "bar(*a)")
-      assert_signature_matches(entry, "bar(1, *a)")
-      assert_signature_matches(entry, "bar(1, *a, 2)")
-      assert_signature_matches(entry, "bar(*a, 2)")
-      assert_signature_matches(entry, "bar(1, **a)")
-      assert_signature_matches(entry, "bar(1) {}")
-      assert_signature_matches(entry, "bar()")
-      assert_signature_matches(entry, "bar(1, 2, 3)")
-      assert_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
-    end
-
-    def test_signature_matches_for_post_forwarding_parameter
-      index(<<~RUBY)
-        class Foo
-          def bar(a, ...)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      # All calls with at least one positional argument match
-      assert_signature_matches(entry, "bar(1)")
-      assert_signature_matches(entry, "bar(1, 2)")
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar(1, ...)")
-      assert_signature_matches(entry, "bar(*a)")
-      assert_signature_matches(entry, "bar(1, *a)")
-      assert_signature_matches(entry, "bar(1, *a, 2)")
-      assert_signature_matches(entry, "bar(*a, 2)")
-      assert_signature_matches(entry, "bar(1, **a)")
-      assert_signature_matches(entry, "bar(1) {}")
-      assert_signature_matches(entry, "bar(1, 2, 3)")
-      assert_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
-      assert_signature_matches(entry, "bar()")
-    end
-
-    def test_signature_matches_for_destructured_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(a, (b, c))
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      # All calls with at least one positional argument match
-      assert_signature_matches(entry, "bar()")
-      assert_signature_matches(entry, "bar(1)")
-      assert_signature_matches(entry, "bar(1, 2)")
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar(1, ...)")
-      assert_signature_matches(entry, "bar(*a)")
-      assert_signature_matches(entry, "bar(1, *a)")
-      assert_signature_matches(entry, "bar(*a, 2)")
-      # This matches because `bar(1, *[], 2)` would result in `bar(1, 2)`, which is a valid call
-      assert_signature_matches(entry, "bar(1, *a, 2)")
-      assert_signature_matches(entry, "bar(1, **a)")
-      assert_signature_matches(entry, "bar(1) {}")
-
-      refute_signature_matches(entry, "bar(1, 2, 3)")
-      refute_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
-    end
-
-    def test_signature_matches_for_post_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(*splat, a)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      # All calls with at least one positional argument match
-      assert_signature_matches(entry, "bar(1)")
-      assert_signature_matches(entry, "bar(1, 2)")
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar(1, ...)")
-      assert_signature_matches(entry, "bar(*a)")
-      assert_signature_matches(entry, "bar(1, *a)")
-      assert_signature_matches(entry, "bar(*a, 2)")
-      assert_signature_matches(entry, "bar(1, *a, 2)")
-      assert_signature_matches(entry, "bar(1, **a)")
-      assert_signature_matches(entry, "bar(1, 2, 3)")
-      assert_signature_matches(entry, "bar(1) {}")
-      assert_signature_matches(entry, "bar()")
-
-      refute_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
-    end
-
-    def test_signature_matches_for_keyword_parameters
-      index(<<~RUBY)
-        class Foo
-          def bar(a:, b: 123)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar()")
-      assert_signature_matches(entry, "bar(a: 1)")
-      assert_signature_matches(entry, "bar(a: 1, b: 32)")
-
-      refute_signature_matches(entry, "bar(a: 1, c: 2)")
-      refute_signature_matches(entry, "bar(1, ...)")
-      refute_signature_matches(entry, "bar(1) {}")
-      refute_signature_matches(entry, "bar(1, *a)")
-      refute_signature_matches(entry, "bar(*a, 2)")
-      refute_signature_matches(entry, "bar(1, *a, 2)")
-      refute_signature_matches(entry, "bar(1, **a)")
-      refute_signature_matches(entry, "bar(*a)")
-      refute_signature_matches(entry, "bar(1)")
-      refute_signature_matches(entry, "bar(1, 2)")
-      refute_signature_matches(entry, "bar(1, 2, a: 1, b: 5) {}")
-    end
-
-    def test_signature_matches_for_keyword_splats
-      index(<<~RUBY)
-        class Foo
-          def bar(a, b:, **kwargs)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-
-      assert_signature_matches(entry, "bar(...)")
-      assert_signature_matches(entry, "bar()")
-      assert_signature_matches(entry, "bar(1)")
-      assert_signature_matches(entry, "bar(1, b: 2)")
-      assert_signature_matches(entry, "bar(1, b: 2, c: 3, d: 4)")
-
-      refute_signature_matches(entry, "bar(1, 2, b: 2)")
-    end
-
-    def test_partial_signature_matches
-      # It's important to match signatures partially, because we want to figure out which signature we should show while
-      # the user is in the middle of typing
-      index(<<~RUBY)
-        class Foo
-          def bar(a:, b:)
-          end
-
-          def baz(a, b)
-          end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      assert_signature_matches(entry, "bar(a: 1)")
-
-      entry = @index["baz"]&.first #: as Entry::Method
-      assert_signature_matches(entry, "baz(1)")
-    end
-
-    def test_module_function_with_no_arguments
-      index(<<~RUBY)
-        module Foo
-          def bar; end
-
-          module_function
-
-          def baz; end
-          attr_reader :attribute
-
-          public
-
-          def qux; end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      assert_predicate(entry, :public?)
-      assert_equal("Foo", entry.owner&.name)
-
-      instance_baz, singleton_baz = @index["baz"] #: as Array[Entry::Method]
-      assert_predicate(instance_baz, :private?)
-      assert_equal("Foo", instance_baz&.owner&.name)
-
-      assert_predicate(singleton_baz, :public?)
-      assert_equal("Foo::<Class:Foo>", singleton_baz&.owner&.name)
-
-      # After invoking `public`, the state of `module_function` is reset
-      instance_qux, singleton_qux = @index["qux"] #: as Array[Entry::Method]
-      assert_nil(singleton_qux)
-      assert_predicate(instance_qux, :public?)
-      assert_equal("Foo", instance_baz&.owner&.name)
-
-      # Attributes are not turned into class methods, they do become private
-      instance_attribute, singleton_attribute = @index["attribute"] #: as Array[Entry::Method]
-      assert_nil(singleton_attribute)
-      assert_equal("Foo", instance_attribute&.owner&.name)
-      assert_predicate(instance_attribute, :private?)
-    end
-
-    def test_module_function_does_nothing_in_classes
-      # Invoking `module_function` in a class raises an error. We simply ignore it
-      index(<<~RUBY)
-        class Foo
-          def bar; end
-
-          module_function
-
-          def baz; end
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      assert_predicate(entry, :public?)
-      assert_equal("Foo", entry.owner&.name)
-
-      entry = @index["baz"]&.first #: as Entry::Method
-      assert_predicate(entry, :public?)
-      assert_equal("Foo", entry.owner&.name)
-    end
-
-    def test_making_several_class_methods_private
-      index(<<~RUBY)
-        class Foo
-          def self.bar; end
-          def self.baz; end
-          def self.qux; end
-
-          private_class_method :bar, :baz, :qux
-
-          def initialize
-          end
-        end
-      RUBY
-    end
-
-    def test_changing_visibility_post_definition
-      index(<<~RUBY)
-        class Foo
-          def bar; end
-          private :bar
-
-          def baz; end
-          protected :baz
-
-          private
-          def qux; end
-
-          public :qux
-        end
-      RUBY
-
-      entry = @index["bar"]&.first #: as Entry::Method
-      assert_predicate(entry, :private?)
-
-      entry = @index["baz"]&.first #: as Entry::Method
-      assert_predicate(entry, :protected?)
-
-      entry = @index["qux"]&.first #: as Entry::Method
-      assert_predicate(entry, :public?)
-    end
-
-    def test_handling_attr
-      index(<<~RUBY)
-        class Foo
-          attr :bar
-          attr :baz, true
-          attr :qux, false
-        end
-      RUBY
-
-      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:1-8:1-11")
-      assert_no_entry("bar=")
-      assert_entry("baz", Entry::Accessor, "/fake/path/foo.rb:2-8:2-11")
-      assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:2-8:2-11")
-      assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:3-8:3-11")
-      assert_no_entry("qux=")
-    end
-
-    private
-
-    #: (Entry::Method entry, String call_string) -> void
-    def assert_signature_matches(entry, call_string)
-      sig = entry.signatures.first #: as !nil
-      arguments = parse_prism_args(call_string)
-      assert(sig.matches?(arguments), "Expected #{call_string} to match #{entry.name}#{entry.decorated_parameters}")
-    end
-
-    #: (Entry::Method entry, String call_string) -> void
-    def refute_signature_matches(entry, call_string)
-      sig = entry.signatures.first #: as !nil
-      arguments = parse_prism_args(call_string)
-      refute(sig.matches?(arguments), "Expected #{call_string} to not match #{entry.name}#{entry.decorated_parameters}")
-    end
-
-    def parse_prism_args(s)
-      Array(Prism.parse(s).value.statements.body.first.arguments&.arguments)
-    end
-  end
-end