ruby-lsp 0.17.17 → 0.18.3

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -242,6 +242,64 @@ module RubyIndexer
       completion_items.values.map!(&:first)
     end
 
+    sig do
+      params(
+        name: String,
+        nesting: T::Array[String],
+      ).returns(T::Array[T::Array[T.any(
+        Entry::Constant,
+        Entry::ConstantAlias,
+        Entry::Namespace,
+        Entry::UnresolvedConstantAlias,
+      )]])
+    end
+    def constant_completion_candidates(name, nesting)
+      # If we have a top level reference, then we don't need to include completions inside the current nesting
+      if name.start_with?("::")
+        return T.cast(
+          @entries_tree.search(name.delete_prefix("::")),
+          T::Array[T::Array[T.any(
+            Entry::Constant,
+            Entry::ConstantAlias,
+            Entry::Namespace,
+            Entry::UnresolvedConstantAlias,
+          )]],
+        )
+      end
+
+      # Otherwise, we have to include every possible constant the user might be referring to. This is essentially the
+      # same algorithm as resolve, but instead of returning early we concatenate all unique results
+
+      # Direct constants inside this namespace
+      entries = @entries_tree.search(nesting.any? ? "#{nesting.join("::")}::#{name}" : name)
+
+      # Constants defined in enclosing scopes
+      nesting.length.downto(1) do |i|
+        namespace = T.must(nesting[0...i]).join("::")
+        entries.concat(@entries_tree.search("#{namespace}::#{name}"))
+      end
+
+      # Inherited constants
+      if name.end_with?("::")
+        entries.concat(inherited_constant_completion_candidates(nil, nesting + [name]))
+      else
+        entries.concat(inherited_constant_completion_candidates(name, nesting))
+      end
+
+      # Top level constants
+      entries.concat(@entries_tree.search(name))
+      entries.uniq!
+      T.cast(
+        entries,
+        T::Array[T::Array[T.any(
+          Entry::Constant,
+          Entry::ConstantAlias,
+          Entry::Namespace,
+          Entry::UnresolvedConstantAlias,
+        )]],
+      )
+    end
+
     # Resolve a constant to its declaration based on its name and the nesting where the reference was found. Parameter
     # documentation:
     #
@@ -312,12 +370,12 @@ module RubyIndexer
           break unless block.call(progress)
         end
 
-        index_single(path)
+        index_single(path, collect_comments: false)
       end
     end
 
-    sig { params(indexable_path: IndexablePath, source: T.nilable(String)).void }
-    def index_single(indexable_path, source = nil)
+    sig { params(indexable_path: IndexablePath, source: T.nilable(String), collect_comments: T::Boolean).void }
+    def index_single(indexable_path, source = nil, collect_comments: true)
       content = source || File.read(indexable_path.full_path)
       dispatcher = Prism::Dispatcher.new
 
@@ -327,6 +385,7 @@ module RubyIndexer
         dispatcher,
         result,
         indexable_path.full_path,
+        collect_comments: collect_comments,
         enhancements: @enhancements,
       )
       dispatcher.dispatch(result.value)
@@ -364,12 +423,10 @@ module RubyIndexer
     # aliases, so we have to invoke `follow_aliased_namespace` again to check until we only return a real name
     sig { params(name: String, seen_names: T::Array[String]).returns(String) }
     def follow_aliased_namespace(name, seen_names = [])
-      return name if @entries[name]
-
       parts = name.split("::")
       real_parts = []
 
-      (parts.length - 1).downto(0).each do |i|
+      (parts.length - 1).downto(0) do |i|
         current_name = T.must(parts[0..i]).join("::")
         entry = @entries[current_name]&.first
 
@@ -607,7 +664,7 @@ module RubyIndexer
           attached_ancestor.file_path,
           attached_ancestor.location,
           attached_ancestor.name_location,
-          [],
+          nil,
           nil,
         )
         add(singleton, skip_prefix_tree: true)
@@ -823,7 +880,7 @@ module RubyIndexer
       )]))
     end
     def lookup_enclosing_scopes(name, nesting, seen_names)
-      nesting.length.downto(1).each do |i|
+      nesting.length.downto(1) do |i|
         namespace = T.must(nesting[0...i]).join("::")
 
         # If we find an entry with `full_name` directly, then we can already return it, even if it contains aliases -
@@ -870,6 +927,51 @@ module RubyIndexer
       nil
     end
 
+    sig do
+      params(
+        name: T.nilable(String),
+        nesting: T::Array[String],
+      ).returns(T::Array[T::Array[T.any(
+        Entry::Namespace,
+        Entry::ConstantAlias,
+        Entry::UnresolvedConstantAlias,
+        Entry::Constant,
+      )]])
+    end
+    def inherited_constant_completion_candidates(name, nesting)
+      namespace_entries = if name
+        *nesting_parts, constant_name = build_non_redundant_full_name(name, nesting).split("::")
+        return [] if nesting_parts.empty?
+
+        resolve(nesting_parts.join("::"), [])
+      else
+        resolve(nesting.join("::"), [])
+      end
+      return [] unless namespace_entries
+
+      ancestors = linearized_ancestors_of(T.must(namespace_entries.first).name)
+      candidates = ancestors.flat_map do |ancestor_name|
+        @entries_tree.search("#{ancestor_name}::#{constant_name}")
+      end
+
+      # For candidates with the same name, we must only show the first entry in the inheritance chain, since that's the
+      # one the user will be referring to in completion
+      completion_items = candidates.each_with_object({}) do |entries, hash|
+        *parts, short_name = T.must(entries.first).name.split("::")
+        namespace_name = parts.join("::")
+        ancestor_index = ancestors.index(namespace_name)
+        existing_entry, existing_entry_index = hash[short_name]
+
+        next unless ancestor_index && (!existing_entry || ancestor_index < existing_entry_index)
+
+        hash[short_name] = [entries, ancestor_index]
+      end
+
+      completion_items.values.map!(&:first)
+    rescue NonExistingNamespaceError
+      []
+    end
+
     # Removes redudancy from a constant reference's full name. For example, if we find a reference to `A::B::Foo` inside
     # of the ["A", "B"] nesting, then we should not concatenate the nesting with the name or else we'll end up with
     # `A::B::A::B::Foo`. This method will remove any redundant parts from the final name based on the reference and the

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -272,10 +272,10 @@ module RubyIndexer
         RBS::AST::Declarations::Constant,
         RBS::AST::Members::MethodDefinition,
         RBS::AST::Members::Alias,
-      )).returns(T::Array[String])
+      )).returns(T.nilable(String))
     end
     def comments_to_string(declaration)
-      Array(declaration.comment&.string)
+      declaration.comment&.string
     end
   end
 end

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -213,10 +213,10 @@ module RubyIndexer
       RUBY
 
       foo_entry = @index["Foo"].first
-      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments)
 
       bar_entry = @index["Bar"].first
-      assert_equal("This Bar comment has 1 line padding", bar_entry.comments.join("\n"))
+      assert_equal("This Bar comment has 1 line padding", bar_entry.comments)
     end
 
     def test_skips_comments_containing_invalid_encodings
@@ -239,10 +239,10 @@ module RubyIndexer
       RUBY
 
       foo_entry = @index["Foo"].first
-      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment\nThis is another Foo comment", foo_entry.comments)
 
       bar_entry = @index["Foo::Bar"].first
-      assert_equal("This is a Bar comment", bar_entry.comments.join("\n"))
+      assert_equal("This is a Bar comment", bar_entry.comments)
     end
 
     def test_comments_can_be_attached_to_a_reopened_class
@@ -255,10 +255,10 @@ module RubyIndexer
       RUBY
 
       first_foo_entry = @index["Foo"][0]
-      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment", first_foo_entry.comments)
 
       second_foo_entry = @index["Foo"][1]
-      assert_equal("This is another Foo comment", second_foo_entry.comments.join("\n"))
+      assert_equal("This is another Foo comment", second_foo_entry.comments)
     end
 
     def test_comments_removes_the_leading_pound_and_space
@@ -271,10 +271,10 @@ module RubyIndexer
       RUBY
 
       first_foo_entry = @index["Foo"][0]
-      assert_equal("This is a Foo comment", first_foo_entry.comments.join("\n"))
+      assert_equal("This is a Foo comment", first_foo_entry.comments)
 
       second_foo_entry = @index["Bar"][0]
-      assert_equal("This is a Bar comment", second_foo_entry.comments.join("\n"))
+      assert_equal("This is a Bar comment", second_foo_entry.comments)
     end
 
     def test_private_class_and_module_indexing
@@ -483,7 +483,7 @@ module RubyIndexer
 
       foo = T.must(@index["Foo::<Class:Foo>"].first)
       assert_equal(4, foo.location.start_line)
-      assert_equal("Some extra comments", foo.comments.join("\n"))
+      assert_equal("Some extra comments", foo.comments)
     end
 
     def test_dynamic_singleton_class_blocks
@@ -501,7 +501,7 @@ module RubyIndexer
       # That pattern cannot be properly analyzed statically and assuming that it's always a regular singleton simplifies
       # the implementation considerably.
       assert_equal(3, singleton.location.start_line)
-      assert_equal("Some extra comments", singleton.comments.join("\n"))
+      assert_equal("Some extra comments", singleton.comments)
     end
 
     def test_namespaces_inside_singleton_blocks
@@ -605,5 +605,19 @@ module RubyIndexer
       assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:2-4:3-7")
       assert_entry("Qux", Entry::Class, "/fake/path/foo.rb:5-4:6-7")
     end
+
+    def test_lazy_comment_fetching_uses_correct_line_breaks_for_rendering
+      path = "lib/ruby_lsp/node_context.rb"
+      indexable = IndexablePath.new("#{Dir.pwd}/lib", path)
+
+      @index.index_single(indexable, collect_comments: false)
+
+      entry = @index["RubyLsp::NodeContext"].first
+
+      assert_equal(<<~COMMENTS.chomp, entry.comments)
+        This class allows listeners to access contextual information about a node in the AST, such as its parent,
+        its namespace nesting, and the surrounding CallNode (e.g. a method call).
+      COMMENTS
+    end
   end
 end

data/lib/ruby_indexer/test/constant_test.rb

@@ -86,16 +86,16 @@ module RubyIndexer
         A::BAZ = 1
       RUBY
 
-      foo_comment = @index["FOO"].first.comments.join("\n")
+      foo_comment = @index["FOO"].first.comments
       assert_equal("FOO comment", foo_comment)
 
-      a_foo_comment = @index["A::FOO"].first.comments.join("\n")
+      a_foo_comment = @index["A::FOO"].first.comments
       assert_equal("A::FOO comment", a_foo_comment)
 
-      bar_comment = @index["BAR"].first.comments.join("\n")
+      bar_comment = @index["BAR"].first.comments
       assert_equal("::BAR comment", bar_comment)
 
-      a_baz_comment = @index["A::BAZ"].first.comments.join("\n")
+      a_baz_comment = @index["A::BAZ"].first.comments
       assert_equal("A::BAZ comment", a_baz_comment)
     end
 

data/lib/ruby_indexer/test/enhancements_test.rb

@@ -38,7 +38,7 @@ module RubyIndexer
               file_path,
               location,
               location,
-              [],
+              nil,
               [Entry::Signature.new([Entry::RequiredParameter.new(name: :a)])],
               Entry::Visibility::PUBLIC,
               owner,
@@ -120,7 +120,7 @@ module RubyIndexer
             file_path,
             location,
             location,
-            [],
+            nil,
             [],
             Entry::Visibility::PUBLIC,
             owner,

data/lib/ruby_indexer/test/index_test.rb

@@ -1863,5 +1863,73 @@ module RubyIndexer
     def test_entries_for_returns_nil_if_no_matches
       assert_nil(@index.entries_for("non_existing_file.rb", Entry::Namespace))
     end
+
+    def test_constant_completion_candidates_all_possible_constants
+      index(<<~RUBY)
+        XQRK = 3
+
+        module Bar
+          XQRK = 2
+        end
+
+        module Foo
+          XQRK = 1
+        end
+
+        module Namespace
+          XQRK = 0
+
+          class Baz
+            include Foo
+            include Bar
+          end
+        end
+      RUBY
+
+      result = @index.constant_completion_candidates("X", ["Namespace", "Baz"])
+
+      result.each do |entries|
+        name = entries.first.name
+        assert(entries.all? { |e| e.name == name })
+      end
+
+      assert_equal(["Namespace::XQRK", "Bar::XQRK", "XQRK"], result.map { |entries| entries.first.name })
+
+      result = @index.constant_completion_candidates("::X", ["Namespace", "Baz"])
+      assert_equal(["XQRK"], result.map { |entries| entries.first.name })
+    end
+
+    def test_constant_completion_candidates_for_empty_name
+      index(<<~RUBY)
+        module Foo
+          Bar = 1
+        end
+
+        class Baz
+          include Foo
+        end
+      RUBY
+
+      result = @index.constant_completion_candidates("Baz::", [])
+      assert_includes(result.map { |entries| entries.first.name }, "Foo::Bar")
+    end
+
+    def test_follow_alias_namespace
+      index(<<~RUBY)
+        module First
+          module Second
+            class Foo
+            end
+          end
+        end
+
+        module Namespace
+          Second = First::Second
+        end
+      RUBY
+
+      real_namespace = @index.follow_aliased_namespace("Namespace::Second")
+      assert_equal("First::Second", real_namespace)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -330,6 +330,33 @@ module RubyIndexer
       assert_empty(parameters)
     end
 
+    def test_methods_with_argument_forwarding
+      index(<<~RUBY)
+        class Foo
+          def bar(...)
+          end
+
+          def baz(a, ...)
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_instance_of(Entry::Method, entry, "Expected `bar` to be indexed")
+
+      parameters = entry.signatures.first.parameters
+      assert_equal(1, parameters.length)
+      assert_instance_of(Entry::ForwardingParameter, parameters.first)
+
+      entry = T.must(@index["baz"].first)
+      assert_instance_of(Entry::Method, entry, "Expected `baz` to be indexed")
+
+      parameters = entry.signatures.first.parameters
+      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
@@ -355,9 +382,9 @@ module RubyIndexer
       RUBY
 
       assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:2-15:2-18")
-      assert_equal("Hello there", @index["bar"].first.comments.join("\n"))
+      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.join("\n"))
+      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")
@@ -461,5 +488,233 @@ module RubyIndexer
       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 = T.must(@index["bar"].first)
+
+      # 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 = T.must(@index["bar"].first)
+
+      # 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 = T.must(@index["bar"].first)
+
+      # 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 = T.must(@index["bar"].first)
+
+      # 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 = T.must(@index["bar"].first)
+
+      # 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 = T.must(@index["bar"].first)
+
+      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 = T.must(@index["bar"].first)
+
+      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 = T.must(@index["bar"].first)
+      assert_signature_matches(entry, "bar(a: 1)")
+
+      entry = T.must(@index["baz"].first)
+      assert_signature_matches(entry, "baz(1)")
+    end
+
+    private
+
+    sig { params(entry: Entry::Method, call_string: String).void }
+    def assert_signature_matches(entry, call_string)
+      sig = T.must(entry.signatures.first)
+      arguments = parse_prism_args(call_string)
+      assert(sig.matches?(arguments), "Expected #{call_string} to match #{entry.name}#{entry.decorated_parameters}")
+    end
+
+    sig { params(entry: Entry::Method, call_string: String).void }
+    def refute_signature_matches(entry, call_string)
+      sig = T.must(entry.signatures.first)
+      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

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -345,7 +345,7 @@ module RubyIndexer
       assert_equal("all?", entry.old_name)
       assert_equal("Array", entry.owner.name)
       assert(entry.file_path.end_with?("core/array.rbs"))
-      assert_includes(entry.comments[0], "Returns `true` if any element of `self` meets a given criterion.")
+      assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
     end
 
     private