ruby-lsp 0.23.11 → 0.23.12

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

@@ -3,16 +3,14 @@
 
 module RubyIndexer
   class RBSIndexer
-    extend T::Sig
-
     HAS_UNTYPED_FUNCTION = T.let(!!defined?(RBS::Types::UntypedFunction), T::Boolean)
 
-    sig { params(index: Index).void }
+    #: (Index index) -> void
     def initialize(index)
       @index = index
     end
 
-    sig { void }
+    #: -> void
     def index_ruby_core
       loader = RBS::EnvironmentLoader.new
       RBS::Environment.from_loader(loader).resolve_type_names
@@ -22,12 +20,7 @@ module RubyIndexer
       end
     end
 
-    sig do
-      params(
-        pathname: Pathname,
-        declarations: T::Array[RBS::AST::Declarations::Base],
-      ).void
-    end
+    #: (Pathname pathname, Array[RBS::AST::Declarations::Base] declarations) -> void
     def process_signature(pathname, declarations)
       declarations.each do |declaration|
         process_declaration(declaration, pathname)
@@ -36,7 +29,7 @@ module RubyIndexer
 
     private
 
-    sig { params(declaration: RBS::AST::Declarations::Base, pathname: Pathname).void }
+    #: (RBS::AST::Declarations::Base declaration, Pathname pathname) -> void
     def process_declaration(declaration, pathname)
       case declaration
       when RBS::AST::Declarations::Class, RBS::AST::Declarations::Module
@@ -51,9 +44,7 @@ module RubyIndexer
       end
     end
 
-    sig do
-      params(declaration: T.any(RBS::AST::Declarations::Class, RBS::AST::Declarations::Module), pathname: Pathname).void
-    end
+    #: ((RBS::AST::Declarations::Class | RBS::AST::Declarations::Module) declaration, Pathname pathname) -> void
     def handle_class_or_module_declaration(declaration, pathname)
       nesting = [declaration.name.name.to_s]
       uri = URI::Generic.from_path(path: pathname.to_s)
@@ -83,7 +74,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(rbs_location: RBS::Location).returns(RubyIndexer::Location) }
+    #: (RBS::Location rbs_location) -> RubyIndexer::Location
     def to_ruby_indexer_location(rbs_location)
       RubyIndexer::Location.new(
         rbs_location.start_line,
@@ -93,12 +84,7 @@ module RubyIndexer
       )
     end
 
-    sig do
-      params(
-        declaration: T.any(RBS::AST::Declarations::Class, RBS::AST::Declarations::Module),
-        entry: Entry::Namespace,
-      ).void
-    end
+    #: ((RBS::AST::Declarations::Class | RBS::AST::Declarations::Module) declaration, Entry::Namespace entry) -> void
     def add_declaration_mixins_to_entry(declaration, entry)
       declaration.each_mixin do |mixin|
         name = mixin.name.name.to_s
@@ -114,7 +100,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(member: RBS::AST::Members::MethodDefinition, owner: Entry::Namespace).void }
+    #: (RBS::AST::Members::MethodDefinition member, Entry::Namespace owner) -> void
     def handle_method(member, owner)
       name = member.name.name
       uri = URI::Generic.from_path(path: member.location.buffer.name)
@@ -144,7 +130,7 @@ module RubyIndexer
       ))
     end
 
-    sig { params(member: RBS::AST::Members::MethodDefinition).returns(T::Array[Entry::Signature]) }
+    #: (RBS::AST::Members::MethodDefinition member) -> Array[Entry::Signature]
     def signatures(member)
       member.overloads.map do |overload|
         parameters = process_overload(overload)
@@ -152,7 +138,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(overload: RBS::AST::Members::MethodDefinition::Overload).returns(T::Array[Entry::Parameter]) }
+    #: (RBS::AST::Members::MethodDefinition::Overload overload) -> Array[Entry::Parameter]
     def process_overload(overload)
       function = overload.method_type.type
 
@@ -173,7 +159,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::Parameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::Parameter]
     def parse_arguments(function)
       parameters = []
       parameters.concat(process_required_and_optional_positionals(function))
@@ -185,7 +171,7 @@ module RubyIndexer
       parameters
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::RequiredParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::RequiredParameter]
     def process_required_and_optional_positionals(function)
       argument_offset = 0
 
@@ -209,14 +195,14 @@ module RubyIndexer
       required + optional
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::OptionalParameter]
     def process_trailing_positionals(function)
       function.trailing_positionals.map do |param|
         Entry::OptionalParameter.new(name: param.name)
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(Entry::RestParameter) }
+    #: (RBS::Types::Function function) -> Entry::RestParameter
     def process_rest_positionals(function)
       rest = function.rest_positionals
 
@@ -225,21 +211,21 @@ module RubyIndexer
       Entry::RestParameter.new(name: rest_name)
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::KeywordParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::KeywordParameter]
     def process_required_keywords(function)
       function.required_keywords.map do |name, _param|
         Entry::KeywordParameter.new(name: name)
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(T::Array[Entry::OptionalKeywordParameter]) }
+    #: (RBS::Types::Function function) -> Array[Entry::OptionalKeywordParameter]
     def process_optional_keywords(function)
       function.optional_keywords.map do |name, _param|
         Entry::OptionalKeywordParameter.new(name: name)
       end
     end
 
-    sig { params(function: RBS::Types::Function).returns(Entry::KeywordRestParameter) }
+    #: (RBS::Types::Function function) -> Entry::KeywordRestParameter
     def process_rest_keywords(function)
       param = function.rest_keywords
 
@@ -262,7 +248,7 @@ module RubyIndexer
     # Complex::I = ... # Complex::I is a top-level constant
     #
     # And we need to handle their nesting differently.
-    sig { params(declaration: RBS::AST::Declarations::Constant, nesting: T::Array[String], uri: URI::Generic).void }
+    #: (RBS::AST::Declarations::Constant declaration, Array[String] nesting, URI::Generic uri) -> void
     def handle_constant(declaration, nesting, uri)
       fully_qualified_name = [*nesting, declaration.name.name.to_s].join("::")
       @index.add(Entry::Constant.new(
@@ -273,7 +259,7 @@ module RubyIndexer
       ))
     end
 
-    sig { params(declaration: RBS::AST::Declarations::Global, pathname: Pathname).void }
+    #: (RBS::AST::Declarations::Global declaration, Pathname pathname) -> void
     def handle_global_variable(declaration, pathname)
       name = declaration.name.to_s
       uri = URI::Generic.from_path(path: pathname.to_s)
@@ -288,7 +274,7 @@ module RubyIndexer
       ))
     end
 
-    sig { params(member: RBS::AST::Members::Alias, owner_entry: Entry::Namespace).void }
+    #: (RBS::AST::Members::Alias member, Entry::Namespace owner_entry) -> void
     def handle_signature_alias(member, owner_entry)
       uri = URI::Generic.from_path(path: member.location.buffer.name)
       comments = comments_to_string(member)
@@ -305,16 +291,7 @@ module RubyIndexer
       @index.add(entry)
     end
 
-    sig do
-      params(declaration: T.any(
-        RBS::AST::Declarations::Class,
-        RBS::AST::Declarations::Module,
-        RBS::AST::Declarations::Constant,
-        RBS::AST::Declarations::Global,
-        RBS::AST::Members::MethodDefinition,
-        RBS::AST::Members::Alias,
-      )).returns(T.nilable(String))
-    end
+    #: ((RBS::AST::Declarations::Class | RBS::AST::Declarations::Module | RBS::AST::Declarations::Constant | RBS::AST::Declarations::Global | RBS::AST::Members::MethodDefinition | RBS::AST::Members::Alias) declaration) -> String?
     def comments_to_string(declaration)
       declaration.comment&.string
     end

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -3,8 +3,6 @@
 
 module RubyIndexer
   class ReferenceFinder
-    extend T::Sig
-
     class Target
       extend T::Helpers
 
@@ -12,12 +10,10 @@ module RubyIndexer
     end
 
     class ConstTarget < Target
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :fully_qualified_name
 
-      sig { params(fully_qualified_name: String).void }
+      #: (String fully_qualified_name) -> void
       def initialize(fully_qualified_name)
         super()
         @fully_qualified_name = fully_qualified_name
@@ -25,12 +21,10 @@ module RubyIndexer
     end
 
     class MethodTarget < Target
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :method_name
 
-      sig { params(method_name: String).void }
+      #: (String method_name) -> void
       def initialize(method_name)
         super()
         @method_name = method_name
@@ -38,12 +32,10 @@ module RubyIndexer
     end
 
     class InstanceVariableTarget < Target
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :name
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def initialize(name)
         super()
         @name = name
@@ -51,18 +43,16 @@ module RubyIndexer
     end
 
     class Reference
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :name
 
-      sig { returns(Prism::Location) }
+      #: Prism::Location
       attr_reader :location
 
-      sig { returns(T::Boolean) }
+      #: bool
       attr_reader :declaration
 
-      sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+      #: (String name, Prism::Location location, declaration: bool) -> void
       def initialize(name, location, declaration:)
         @name = name
         @location = location
@@ -70,15 +60,7 @@ module RubyIndexer
       end
     end
 
-    sig do
-      params(
-        target: Target,
-        index: RubyIndexer::Index,
-        dispatcher: Prism::Dispatcher,
-        uri: URI::Generic,
-        include_declarations: T::Boolean,
-      ).void
-    end
+    #: (Target target, RubyIndexer::Index index, Prism::Dispatcher dispatcher, URI::Generic uri, ?include_declarations: bool) -> void
     def initialize(target, index, dispatcher, uri, include_declarations: true)
       @target = target
       @index = index
@@ -119,34 +101,34 @@ module RubyIndexer
       )
     end
 
-    sig { returns(T::Array[Reference]) }
+    #: -> Array[Reference]
     def references
       return @references if @include_declarations
 
       @references.reject(&:declaration)
     end
 
-    sig { params(node: Prism::ClassNode).void }
+    #: (Prism::ClassNode node) -> void
     def on_class_node_enter(node)
       @stack << node.constant_path.slice
     end
 
-    sig { params(node: Prism::ClassNode).void }
+    #: (Prism::ClassNode node) -> void
     def on_class_node_leave(node)
       @stack.pop
     end
 
-    sig { params(node: Prism::ModuleNode).void }
+    #: (Prism::ModuleNode node) -> void
     def on_module_node_enter(node)
       @stack << node.constant_path.slice
     end
 
-    sig { params(node: Prism::ModuleNode).void }
+    #: (Prism::ModuleNode node) -> void
     def on_module_node_leave(node)
       @stack.pop
     end
 
-    sig { params(node: Prism::SingletonClassNode).void }
+    #: (Prism::SingletonClassNode node) -> void
     def on_singleton_class_node_enter(node)
       expression = node.expression
       return unless expression.is_a?(Prism::SelfNode)
@@ -154,12 +136,12 @@ module RubyIndexer
       @stack << "<Class:#{@stack.last}>"
     end
 
-    sig { params(node: Prism::SingletonClassNode).void }
+    #: (Prism::SingletonClassNode node) -> void
     def on_singleton_class_node_leave(node)
       @stack.pop
     end
 
-    sig { params(node: Prism::ConstantPathNode).void }
+    #: (Prism::ConstantPathNode node) -> void
     def on_constant_path_node_enter(node)
       name = Index.constant_name(node)
       return unless name
@@ -167,7 +149,7 @@ module RubyIndexer
       collect_constant_references(name, node.location)
     end
 
-    sig { params(node: Prism::ConstantReadNode).void }
+    #: (Prism::ConstantReadNode node) -> void
     def on_constant_read_node_enter(node)
       name = Index.constant_name(node)
       return unless name
@@ -175,7 +157,7 @@ module RubyIndexer
       collect_constant_references(name, node.location)
     end
 
-    sig { params(node: Prism::MultiWriteNode).void }
+    #: (Prism::MultiWriteNode node) -> void
     def on_multi_write_node_enter(node)
       [*node.lefts, *node.rest, *node.rights].each do |target|
         case target
@@ -185,7 +167,7 @@ module RubyIndexer
       end
     end
 
-    sig { params(node: Prism::ConstantPathWriteNode).void }
+    #: (Prism::ConstantPathWriteNode node) -> void
     def on_constant_path_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -196,7 +178,7 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    #: (Prism::ConstantPathOrWriteNode node) -> void
     def on_constant_path_or_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -207,7 +189,7 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    #: (Prism::ConstantPathOperatorWriteNode node) -> void
     def on_constant_path_operator_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -218,7 +200,7 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    #: (Prism::ConstantPathAndWriteNode node) -> void
     def on_constant_path_and_write_node_enter(node)
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -229,27 +211,27 @@ module RubyIndexer
       collect_constant_references(name, target.location)
     end
 
-    sig { params(node: Prism::ConstantWriteNode).void }
+    #: (Prism::ConstantWriteNode node) -> void
     def on_constant_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::ConstantOrWriteNode).void }
+    #: (Prism::ConstantOrWriteNode node) -> void
     def on_constant_or_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::ConstantAndWriteNode).void }
+    #: (Prism::ConstantAndWriteNode node) -> void
     def on_constant_and_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::ConstantOperatorWriteNode).void }
+    #: (Prism::ConstantOperatorWriteNode node) -> void
     def on_constant_operator_write_node_enter(node)
       collect_constant_references(node.name.to_s, node.name_loc)
     end
 
-    sig { params(node: Prism::DefNode).void }
+    #: (Prism::DefNode node) -> void
     def on_def_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
         @references << Reference.new(name, node.name_loc, declaration: true)
@@ -260,44 +242,44 @@ module RubyIndexer
       end
     end
 
-    sig { params(node: Prism::DefNode).void }
+    #: (Prism::DefNode node) -> void
     def on_def_node_leave(node)
       if node.receiver.is_a?(Prism::SelfNode)
         @stack.pop
       end
     end
 
-    sig { params(node: Prism::InstanceVariableReadNode).void }
+    #: (Prism::InstanceVariableReadNode node) -> void
     def on_instance_variable_read_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.location, false)
     end
 
-    sig { params(node: Prism::InstanceVariableWriteNode).void }
+    #: (Prism::InstanceVariableWriteNode node) -> void
     def on_instance_variable_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+    #: (Prism::InstanceVariableAndWriteNode node) -> void
     def on_instance_variable_and_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+    #: (Prism::InstanceVariableOperatorWriteNode node) -> void
     def on_instance_variable_operator_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+    #: (Prism::InstanceVariableOrWriteNode node) -> void
     def on_instance_variable_or_write_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.name_loc, true)
     end
 
-    sig { params(node: Prism::InstanceVariableTargetNode).void }
+    #: (Prism::InstanceVariableTargetNode node) -> void
     def on_instance_variable_target_node_enter(node)
       collect_instance_variable_references(node.name.to_s, node.location, true)
     end
 
-    sig { params(node: Prism::CallNode).void }
+    #: (Prism::CallNode node) -> void
     def on_call_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
         @references << Reference.new(name, T.must(node.message_loc), declaration: false)
@@ -306,7 +288,7 @@ module RubyIndexer
 
     private
 
-    sig { params(name: String, location: Prism::Location).void }
+    #: (String name, Prism::Location location) -> void
     def collect_constant_references(name, location)
       return unless @target.is_a?(ConstTarget)
 
@@ -335,7 +317,7 @@ module RubyIndexer
       @references << Reference.new(name, location, declaration: declaration)
     end
 
-    sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+    #: (String name, Prism::Location location, bool declaration) -> void
     def collect_instance_variable_references(name, location, declaration)
       return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
 

data/lib/ruby_indexer/lib/ruby_indexer/uri.rb

@@ -1,26 +1,19 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "uri"
+
 module URI
   class Generic
-    extend T::Sig
-
     # Avoid a deprecation warning with Ruby 3.4 where the default parser was changed to RFC3986.
     # This condition must remain even after support for 3.4 has been dropped for users that have
     # `uri` in their lockfile, decoupling it from the ruby version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
 
-    class << self
-      extend T::Sig
+    # NOTE: We also define this in the shim
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER
 
-      sig do
-        params(
-          path: String,
-          fragment: T.nilable(String),
-          scheme: String,
-          load_path_entry: T.nilable(String),
-        ).returns(URI::Generic)
-      end
+    class << self
+      #: (path: String, ?fragment: String?, ?scheme: String, ?load_path_entry: String?) -> URI::Generic
       def from_path(path:, fragment: nil, scheme: "file", load_path_entry: nil)
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
         escaped_path = if /^[A-Z]:/i.match?(path)
@@ -42,10 +35,10 @@ module URI
       end
     end
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_accessor :require_path
 
-    sig { params(load_path_entry: String).void }
+    #: (String load_path_entry) -> void
     def add_require_path_from_load_entry(load_path_entry)
       path = to_standardized_path
       return unless path
@@ -53,7 +46,7 @@ module URI
       self.require_path = path.delete_prefix("#{load_path_entry}/").delete_suffix(".rb")
     end
 
-    sig { returns(T.nilable(String)) }
+    #: -> String?
     def to_standardized_path
       parsed_path = path
       return unless parsed_path

data/lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb

@@ -5,29 +5,25 @@ module RubyIndexer
   # Represents the visibility scope in a Ruby namespace. This keeps track of whether methods are in a public, private or
   # protected section, and whether they are module functions.
   class VisibilityScope
-    extend T::Sig
-
     class << self
-      extend T::Sig
-
-      sig { returns(T.attached_class) }
+      #: -> instance
       def module_function_scope
         new(module_func: true, visibility: Entry::Visibility::PRIVATE)
       end
 
-      sig { returns(T.attached_class) }
+      #: -> instance
       def public_scope
         new
       end
     end
 
-    sig { returns(Entry::Visibility) }
+    #: Entry::Visibility
     attr_reader :visibility
 
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :module_func
 
-    sig { params(visibility: Entry::Visibility, module_func: T::Boolean).void }
+    #: (?visibility: Entry::Visibility, ?module_func: bool) -> void
     def initialize(visibility: Entry::Visibility::PUBLIC, module_func: false)
       @visibility = visibility
       @module_func = module_func

data/lib/ruby_indexer/test/configuration_test.rb

@@ -12,7 +12,7 @@ module RubyIndexer
     end
 
     def test_load_configuration_executes_configure_block
-      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*.rb"] })
+      @config.apply_config({ "excluded_patterns" => ["**/fixtures/**/*"] })
       uris = @config.indexable_uris
 
       bundle_path = Bundler.bundle_path.join("gems")
@@ -39,7 +39,11 @@ module RubyIndexer
         next if lazy_spec.name == "ruby-lsp"
 
         spec = Gem::Specification.find_by_name(lazy_spec.name)
-        assert(uris.none? { |uri| uri.full_path.start_with?("#{spec.full_gem_path}/test/") })
+
+        test_uris = uris.select do |uri|
+          File.fnmatch?(File.join(spec.full_gem_path, "test/**/*"), uri.full_path, File::Constants::FNM_PATHNAME)
+        end
+        assert_empty(test_uris)
       rescue Gem::MissingSpecError
         # Transitive dependencies might be missing when running tests on Windows
       end
@@ -235,5 +239,31 @@ module RubyIndexer
         end
       end
     end
+
+    def test_indexables_include_non_test_files_in_test_directories
+      # In order to linearize test parent classes and accurately detect the framework being used, then intermediate
+      # parent classes _must_ also be indexed. Otherwise, we have no way of linearizing the rest of the ancestors to
+      # determine what the test class ultimately inherits from.
+      #
+      # Therefore, we need to ensure that test files are excluded, but non test files inside test directories have to be
+      # indexed
+      FileUtils.touch("test/test_case.rb")
+
+      uris = @config.indexable_uris
+      project_paths = uris.filter_map do |uri|
+        path = uri.full_path
+        next if path.start_with?(Bundler.bundle_path.to_s) || path.start_with?(RbConfig::CONFIG["rubylibdir"])
+
+        Pathname.new(path).relative_path_from(Dir.pwd).to_s
+      end
+
+      begin
+        assert_includes(project_paths, "test/requests/support/expectations_test_runner.rb")
+        assert_includes(project_paths, "test/test_helper.rb")
+        assert_includes(project_paths, "test/test_case.rb")
+      ensure
+        FileUtils.rm("test/test_case.rb")
+      end
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -926,14 +926,14 @@ module RubyIndexer
 
     private
 
-    sig { params(entry: Entry::Method, call_string: String).void }
+    #: (Entry::Method entry, String call_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 }
+    #: (Entry::Method entry, String call_string) -> void
     def refute_signature_matches(entry, call_string)
       sig = T.must(entry.signatures.first)
       arguments = parse_prism_args(call_string)