ruby-lsp 0.17.16 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc4416ea8876d8207b6c1955cd47af5f3312a0f0dc3644563bfd35138a903535
-  data.tar.gz: 5961dd8ca49539c20049509c0afed8b2442c3d16ec12d1fb84c9e45dbd027760
+  metadata.gz: 407c26b9ad43a3992fc5b007456dba7c370f4ba6bf398a68bebdfaaafc58ba81
+  data.tar.gz: b890b6762b8d1b4fe43632d6d74e3b0fc1e83168f8d51ccbd2b659df389bff42
 SHA512:
-  metadata.gz: 4b77547221c1750871ff6e1a3635b0ae6f945b86862f484d20eb7587a1feb9830e1d1d7770f16c2e7efeb70e6a953529041f8acc8fe3d7c30940687d20563f96
-  data.tar.gz: 1093a1a6ac45e8627f26a6c9dbb0017079d2804904fe9a4303e3698d4131c6eeedf2bbafac93e6475f676860624b9c53d482c52cfe8380e67ed05ce525e99957
+  metadata.gz: 75a2a425311f1b07969fea0849b7b214babd8b455d1a93a4c1883a75df7f26ec9d7c7e2748a7499a404313eb93ec3391a19d22102bc0658d9eb296f4ceaf48a4
+  data.tar.gz: 536fd4d95c63b493f83a1620307d21f8aa2c96b71bc3782975f55173bc5c7027be5399928a19508bb2ed08f222ae86d075d721e30b334dae7fa097caf71fb558

data/README.md

@@ -15,119 +15,13 @@ experience to Ruby developers using modern standards for cross-editor features,
 Want to discuss Ruby developer experience? Consider joining the public
 [Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-2c8zjlir6-uUDJl8oIwcen_FS_aA~b6Q).
 
-## Features
+## Getting Started
 
-![Ruby LSP demo](vscode/extras/ruby_lsp_demo.gif)
+For VS Code users, you can start by installing the [Ruby LSP extension](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp) from the VS Code marketplace.
 
-The Ruby LSP features include
+For other editors, please refer to the [EDITORS](https://shopify.github.io/ruby-lsp/editors.html) guide.
 
-- Semantic highlighting
-- Symbol search and code outline
-- RuboCop errors and warnings (diagnostics)
-- Format on save (with RuboCop or Syntax Tree)
-- Format on type
-- Debugging support
-- Running and debugging tests through VS Code's UI
-- Go to definition for classes, modules, constants and required files
-- Showing documentation on hover for classes, modules and constants
-- Completion for classes, modules, constants and require paths
-- Fuzzy search classes, modules and constants anywhere in the project and its dependencies (workspace symbol)
-
-As of July 2024, Ruby LSP has received significant enhancements to its code navigation features. For an in-depth look at these improvements, including video demonstrations, check out this [article](https://railsatscale.com/2024-07-18-mastering-ruby-code-navigation-major-enhancements-in-ruby-lsp-2024/). Despite these advancements, we plan to continue enhancing its code navigation support even further. You can follow our progress on this [GitHub issue](https://github.com/Shopify/ruby-lsp/issues/899).
-
-See complete information about features [here](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
-
-If you experience issues, please see the [troubleshooting
-guide](https://github.com/Shopify/ruby-lsp/blob/main/TROUBLESHOOTING.md).
-
-## Usage
-
-### With VS Code
-
-If using VS Code, all you have to do is install the [Ruby LSP
-extension](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp) to get the extra features in the
-editor. Do not install the `ruby-lsp` gem manually.
-
-For more information on using and configuring the extension, see [vscode/README.md](vscode/README.md).
-
-### With other editors
-
-See [editors](EDITORS.md) for community instructions on setting up the Ruby LSP, which current includes Emacs, Neovim, Sublime Text, and Zed.
-
-The gem can be installed by doing
-```shell
-gem install ruby-lsp
-```
-
-and the language server can be launched running `ruby-lsp` (without bundle exec in order to properly hook into your
-project's dependencies).
-
-### Documentation
-
-See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
-[supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
-
-For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
-documentation](SEMANTIC_HIGHLIGHTING.md).
-
-### Configuring code indexing
-
-By default, the Ruby LSP indexes all Ruby files defined in the current project and all of its dependencies, including
-default gems, except for
-
-- Gems that only appear under the `:development` group
-- All Ruby files under `test/**/*.rb`
-
-This behaviour can be overridden and tuned. Learn how to configure it [for VS Code](vscode/README.md#Indexing-Configuration) or [for other editors](EDITORS.md#Indexing-Configuration).
-
-Note that indexing-dependent behavior, such as definition, hover, completion or workspace symbol will be impacted by
-the configuration changes.
-
-The older approach of using a `.index.yml` file has been deprecated and will be removed in a future release.
-
-```yaml
-# Exclude files based on a given pattern. Often used to exclude test files or fixtures
-excluded_patterns:
-  - "**/spec/**/*.rb"
-
-# Include files based on a given pattern. Can be used to index Ruby files that use different extensions
-included_patterns:
-  - "**/bin/*"
-
-# Exclude gems by name. If a gem is never referenced in the project's code and is only used as a tool, excluding it will
-# speed up indexing and reduce the amount of results in features like definition or completion
-excluded_gems:
-  - rubocop
-  - pathname
-
-# Include gems by name. Normally used to include development gems that are excluded by default
-included_gems:
-  - prism
-```
-
-### Addons
-
-The Ruby LSP provides an addon system that allows other gems to enhance the base functionality with more editor
-features. This is the mechanism that powers addons like
-
-- [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
-- [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
-- [Ruby LSP rubyfmt](https://github.com/jscharf/ruby-lsp-rubyfmt)
-
-Additionally, some tools may include a Ruby LSP addon directly, like
-
-- [Standard Ruby (from v1.39.1)](https://github.com/standardrb/standard/wiki/IDE:-vscode#using-ruby-lsp)
-
-Other community driven addons can be found in [rubygems](https://rubygems.org/search?query=name%3A+ruby-lsp) by
-searching for the `ruby-lsp` prefix.
-
-For instructions on how to create addons, see the [addons documentation](ADDONS.md).
-
-## Learn More
-
-* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
-* [Remote Ruby: Ruby Language Server with Vinicius Stock](https://remoteruby.com/221)
-* [RubyKaigi 2023: Code indexing - How language servers understand our code](https://www.youtube.com/watch?v=ks3tQojSJLU) ([Vinicius Stock](https://github.com/vinistock))
+To learn more about Ruby LSP, please refer to the official [documentation](https://shopify.github.io/ruby-lsp) for [supported features](https://shopify.github.io/ruby-lsp#features).
 
 ## Contributing
 

data/VERSION

@@ -1 +1 @@
-0.17.16
+0.18.0

data/exe/ruby-lsp

@@ -64,15 +64,12 @@ if ENV["BUNDLE_GEMFILE"].nil?
   require_relative "../lib/ruby_lsp/setup_bundler"
 
   begin
-    bundle_gemfile, bundle_path, bundle_app_config = RubyLsp::SetupBundler.new(Dir.pwd, **options).setup!
+    env = RubyLsp::SetupBundler.new(Dir.pwd, **options).setup!
   rescue RubyLsp::SetupBundler::BundleNotLocked
     warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
     exit(78)
   end
 
-  env = { "BUNDLE_GEMFILE" => bundle_gemfile }
-  env["BUNDLE_PATH"] = bundle_path if bundle_path
-  env["BUNDLE_APP_CONFIG"] = bundle_app_config if bundle_app_config
   exit exec(env, "bundle exec ruby-lsp #{original_args.join(" ")}")
 end
 
@@ -98,16 +95,17 @@ if options[:debug]
 end
 
 if options[:time_index]
-  require "benchmark"
-
   index = RubyIndexer::Index.new
 
-  result = Benchmark.realtime { index.index_all }
+  time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  index.index_all
+  elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time_start
+
   entries = index.instance_variable_get(:@entries)
   entries_by_entry_type = entries.values.flatten.group_by(&:class)
 
   puts <<~MSG
-    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{result.round(5)} seconds and generated:
+    Ruby LSP v#{RubyLsp::VERSION}: Indexing took #{elapsed_time.round(5)} seconds and generated:
     - #{entries_by_entry_type.sort_by { |k, _| k.to_s }.map { |k, v| "#{k.name.split("::").last}: #{v.size}" }.join("\n- ")}
   MSG
   return
@@ -134,4 +132,8 @@ if options[:doctor]
   return
 end
 
+# Ensure all output goes out stderr by default to allow puts/p/pp to work
+# without specifying output device.
+$> = $stderr
+
 RubyLsp::Server.new.start

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -17,10 +17,11 @@ module RubyIndexer
         dispatcher: Prism::Dispatcher,
         parse_result: Prism::ParseResult,
         file_path: String,
+        collect_comments: T::Boolean,
         enhancements: T::Array[Enhancement],
       ).void
     end
-    def initialize(index, dispatcher, parse_result, file_path, enhancements: [])
+    def initialize(index, dispatcher, parse_result, file_path, collect_comments: false, enhancements: [])
       @index = index
       @file_path = file_path
       @enhancements = enhancements
@@ -40,6 +41,7 @@ module RubyIndexer
       # A stack of namespace entries that represent where we currently are. Used to properly assign methods to an owner
       @owner_stack = T.let([], T::Array[Entry::Namespace])
       @indexing_errors = T.let([], T::Array[String])
+      @collect_comments = collect_comments
 
       dispatcher.register(
         self,
@@ -540,9 +542,11 @@ module RubyIndexer
       )
     end
 
-    sig { params(node: Prism::Node).returns(T::Array[String]) }
+    sig { params(node: Prism::Node).returns(T.nilable(String)) }
     def collect_comments(node)
-      comments = []
+      return unless @collect_comments
+
+      comments = +""
 
       start_line = node.location.start_line - 1
       start_line -= 1 unless @comments_by_line.key?(start_line)
@@ -551,7 +555,7 @@ module RubyIndexer
         comment = @comments_by_line[line]
         break unless comment
 
-        comment_content = comment.location.slice.chomp
+        comment_content = comment.location.slice
 
         # invalid encodings would raise an "invalid byte sequence" exception
         if !comment_content.valid_encoding? || comment_content.match?(@index.configuration.magic_comment_regex)
@@ -560,9 +564,10 @@ module RubyIndexer
 
         comment_content.delete_prefix!("#")
         comment_content.delete_prefix!(" ")
-        comments.prepend(comment_content)
+        comments.prepend("#{comment_content}\n")
       end
 
+      comments.chomp!
       comments
     end
 
@@ -685,9 +690,12 @@ module RubyIndexer
 
       keyword_rest = parameters_node.keyword_rest
 
-      if keyword_rest.is_a?(Prism::KeywordRestParameterNode)
+      case keyword_rest
+      when Prism::KeywordRestParameterNode
         keyword_rest_name = parameter_name(keyword_rest) || Entry::KeywordRestParameter::DEFAULT_NAME
         parameters << Entry::KeywordRestParameter.new(name: keyword_rest_name)
+      when Prism::ForwardingParameterNode
+        parameters << Entry::ForwardingParameter.new
       end
 
       parameters_node.posts.each do |post|

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -24,9 +24,6 @@ module RubyIndexer
 
     alias_method :name_location, :location
 
-    sig { returns(T::Array[String]) }
-    attr_reader :comments
-
     sig { returns(Visibility) }
     attr_accessor :visibility
 
@@ -35,7 +32,7 @@ module RubyIndexer
         name: String,
         file_path: String,
         location: T.any(Prism::Location, RubyIndexer::Location),
-        comments: T::Array[String],
+        comments: T.nilable(String),
       ).void
     end
     def initialize(name, file_path, location, comments)
@@ -79,6 +76,37 @@ module RubyIndexer
       File.basename(@file_path)
     end
 
+    sig { returns(String) }
+    def comments
+      @comments ||= begin
+        # Parse only the comments based on the file path, which is much faster than parsing the entire file
+        parsed_comments = Prism.parse_file_comments(@file_path)
+
+        # Group comments based on whether they belong to a single block of comments
+        grouped = parsed_comments.slice_when do |left, right|
+          left.location.start_line + 1 != right.location.start_line
+        end
+
+        # Find the group that is either immediately or two lines above the current entry
+        correct_group = grouped.find do |group|
+          comment_end_line = group.last.location.start_line
+          (comment_end_line - 1..comment_end_line).cover?(@location.start_line - 1)
+        end
+
+        # If we found something, we join the comments together. Otherwise, the entry has no documentation and we don't
+        # want to accidentally re-parse it, so we set it to an empty string. If an entry is updated, the entire entry
+        # object is dropped, so this will not prevent updates
+        if correct_group
+          correct_group.filter_map do |comment|
+            content = comment.slice
+            content if content.valid_encoding?
+          end.join("\n")
+        else
+          ""
+        end
+      end
+    end
+
     class ModuleOperation
       extend T::Sig
       extend T::Helpers
@@ -116,7 +144,7 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           name_location: T.any(Prism::Location, Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
         ).void
       end
       def initialize(nesting, file_path, location, name_location, comments)
@@ -177,7 +205,7 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           name_location: T.any(Prism::Location, Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
           parent_class: T.nilable(String),
         ).void
       end
@@ -195,7 +223,7 @@ module RubyIndexer
     class SingletonClass < Class
       extend T::Sig
 
-      sig { params(location: Prism::Location, name_location: Prism::Location, comments: T::Array[String]).void }
+      sig { params(location: Prism::Location, name_location: Prism::Location, comments: T.nilable(String)).void }
       def update_singleton_information(location, name_location, comments)
         # Create a new RubyIndexer::Location object from the Prism location
         @location = Location.new(
@@ -210,7 +238,7 @@ module RubyIndexer
           name_location.start_column,
           name_location.end_column,
         )
-        @comments.concat(comments)
+        (@comments ||= +"") << comments if comments
       end
     end
 
@@ -302,6 +330,17 @@ module RubyIndexer
       end
     end
 
+    # A forwarding method parameter, e.g. `def foo(...)`
+    class ForwardingParameter < Parameter
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        # You can't name a forwarding parameter, it's always called `...`
+        super(name: :"...")
+      end
+    end
+
     class Member < Entry
       extend T::Sig
       extend T::Helpers
@@ -311,17 +350,12 @@ module RubyIndexer
       sig { returns(T.nilable(Entry::Namespace)) }
       attr_reader :owner
 
-      sig { returns(T::Array[RubyIndexer::Entry::Parameter]) }
-      def parameters
-        T.must(signatures.first).parameters
-      end
-
       sig do
         params(
           name: String,
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
         ).void
@@ -389,7 +423,7 @@ module RubyIndexer
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
           name_location: T.any(Prism::Location, Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
           signatures: T::Array[Signature],
           visibility: Visibility,
           owner: T.nilable(Entry::Namespace),
@@ -440,7 +474,7 @@ module RubyIndexer
           name: String,
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
         ).void
       end
       def initialize(target, nesting, name, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
@@ -477,7 +511,7 @@ module RubyIndexer
           name: String,
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
           owner: T.nilable(Entry::Namespace),
         ).void
       end
@@ -506,7 +540,7 @@ module RubyIndexer
           owner: T.nilable(Entry::Namespace),
           file_path: String,
           location: T.any(Prism::Location, RubyIndexer::Location),
-          comments: T::Array[String],
+          comments: T.nilable(String),
         ).void
       end
       def initialize(new_name, old_name, owner, file_path, location, comments) # rubocop:disable Metrics/ParameterLists
@@ -530,10 +564,9 @@ module RubyIndexer
 
       sig { params(target: T.any(Member, MethodAlias), unresolved_alias: UnresolvedMethodAlias).void }
       def initialize(target, unresolved_alias)
-        full_comments = ["Alias for #{target.name}\n"]
-        full_comments.concat(unresolved_alias.comments)
-        full_comments << "\n"
-        full_comments.concat(target.comments)
+        full_comments = +"Alias for #{target.name}\n"
+        full_comments << "#{unresolved_alias.comments}\n"
+        full_comments << target.comments
 
         super(
           unresolved_alias.new_name,
@@ -546,11 +579,6 @@ module RubyIndexer
         @owner = T.let(unresolved_alias.owner, T.nilable(Entry::Namespace))
       end
 
-      sig { returns(T::Array[Parameter]) }
-      def parameters
-        @target.parameters
-      end
-
       sig { returns(String) }
       def decorated_parameters
         @target.decorated_parameters
@@ -586,6 +614,108 @@ module RubyIndexer
       def format
         @parameters.map(&:decorated_name).join(", ")
       end
+
+      # Returns `true` if the given call node arguments array matches this method signature. This method will prefer
+      # returning `true` for situations that cannot be analyzed statically, like the presence of splats, keyword splats
+      # or forwarding arguments.
+      #
+      # Since this method is used to detect which overload should be displayed in signature help, it will also return
+      # `true` if there are missing arguments since the user may not be done typing yet. For example:
+      #
+      # ```ruby
+      # def foo(a, b); end
+      # # All of the following are considered matches because the user might be in the middle of typing and we have to
+      # # show them the signature
+      # foo
+      # foo(1)
+      # foo(1, 2)
+      # ```
+      sig { params(arguments: T::Array[Prism::Node]).returns(T::Boolean) }
+      def matches?(arguments)
+        min_pos = 0
+        max_pos = T.let(0, T.any(Integer, Float))
+        names = []
+        has_forward = T.let(false, T::Boolean)
+        has_keyword_rest = T.let(false, T::Boolean)
+
+        @parameters.each do |param|
+          case param
+          when RequiredParameter
+            min_pos += 1
+            max_pos += 1
+          when OptionalParameter
+            max_pos += 1
+          when RestParameter
+            max_pos = Float::INFINITY
+          when ForwardingParameter
+            max_pos = Float::INFINITY
+            has_forward = true
+          when KeywordParameter, OptionalKeywordParameter
+            names << param.name
+          when KeywordRestParameter
+            has_keyword_rest = true
+          end
+        end
+
+        keyword_hash_nodes, positional_args = arguments.partition { |arg| arg.is_a?(Prism::KeywordHashNode) }
+        keyword_args = T.cast(keyword_hash_nodes.first, T.nilable(Prism::KeywordHashNode))&.elements
+        forwarding_arguments, positionals = positional_args.partition do |arg|
+          arg.is_a?(Prism::ForwardingArgumentsNode)
+        end
+
+        return true if has_forward && min_pos == 0
+
+        # If the only argument passed is a forwarding argument, then anything will match
+        (positionals.empty? && forwarding_arguments.any?) ||
+          (
+            # Check if positional arguments match. This includes required, optional, rest arguments. We also need to
+            # verify if there's a trailing forwading argument, like `def foo(a, ...); end`
+            positional_arguments_match?(positionals, forwarding_arguments, keyword_args, min_pos, max_pos) &&
+            # If the positional arguments match, we move on to checking keyword, optional keyword and keyword rest
+            # arguments. If there's a forward argument, then it will always match. If the method accepts a keyword rest
+            # (**kwargs), then we can't analyze statically because the user could be passing a hash and we don't know
+            # what the runtime values inside the hash are.
+            #
+            # If none of those match, then we verify if the user is passing the expect names for the keyword arguments
+            (has_forward || has_keyword_rest || keyword_arguments_match?(keyword_args, names))
+          )
+      end
+
+      sig do
+        params(
+          positional_args: T::Array[Prism::Node],
+          forwarding_arguments: T::Array[Prism::Node],
+          keyword_args: T.nilable(T::Array[Prism::Node]),
+          min_pos: Integer,
+          max_pos: T.any(Integer, Float),
+        ).returns(T::Boolean)
+      end
+      def positional_arguments_match?(positional_args, forwarding_arguments, keyword_args, min_pos, max_pos)
+        # If the method accepts at least one positional argument and a splat has been passed
+        (min_pos > 0 && positional_args.any? { |arg| arg.is_a?(Prism::SplatNode) }) ||
+          # If there's at least one positional argument unaccounted for and a keyword splat has been passed
+          (min_pos - positional_args.length > 0 && keyword_args&.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }) ||
+          # If there's at least one positional argument unaccounted for and a forwarding argument has been passed
+          (min_pos - positional_args.length > 0 && forwarding_arguments.any?) ||
+          # If the number of positional arguments is within the expected range
+          (min_pos > 0 && positional_args.length <= max_pos) ||
+          (min_pos == 0 && positional_args.empty?)
+      end
+
+      sig { params(args: T.nilable(T::Array[Prism::Node]), names: T::Array[Symbol]).returns(T::Boolean) }
+      def keyword_arguments_match?(args, names)
+        return true unless args
+        return true if args.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }
+
+        arg_names = args.filter_map do |arg|
+          next unless arg.is_a?(Prism::AssocNode)
+
+          key = arg.key
+          key.value&.to_sym if key.is_a?(Prism::SymbolNode)
+        end
+
+        (arg_names - names).empty?
+      end
     end
   end
 end

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

@@ -232,7 +232,7 @@ module RubyIndexer
         next unless ancestor_index && (!existing_entry || ancestor_index < existing_entry_index)
 
         if entry.is_a?(Entry::UnresolvedMethodAlias)
-          resolved_alias = resolve_method_alias(entry, receiver_name)
+          resolved_alias = resolve_method_alias(entry, receiver_name, [])
           hash[entry_name] = [resolved_alias, ancestor_index] if resolved_alias.is_a?(Entry::MethodAlias)
         else
           hash[entry_name] = [entry, ancestor_index]
@@ -312,12 +312,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 +327,7 @@ module RubyIndexer
         dispatcher,
         result,
         indexable_path.full_path,
+        collect_comments: collect_comments,
         enhancements: @enhancements,
       )
       dispatcher.dispatch(result.value)
@@ -394,16 +395,18 @@ module RubyIndexer
       real_parts.join("::")
     end
 
-    # Attempts to find methods for a resolved fully qualified receiver name.
+    # Attempts to find methods for a resolved fully qualified receiver name. Do not provide the `seen_names` parameter
+    # as it is used only internally to prevent infinite loops when resolving circular aliases
     # Returns `nil` if the method does not exist on that receiver
     sig do
       params(
         method_name: String,
         receiver_name: String,
+        seen_names: T::Array[String],
         inherited_only: T::Boolean,
       ).returns(T.nilable(T::Array[T.any(Entry::Member, Entry::MethodAlias)]))
     end
-    def resolve_method(method_name, receiver_name, inherited_only: false)
+    def resolve_method(method_name, receiver_name, seen_names = [], inherited_only: false)
       method_entries = self[method_name]
       return unless method_entries
 
@@ -418,7 +421,7 @@ module RubyIndexer
           when Entry::UnresolvedMethodAlias
             # Resolve aliases lazily as we find them
             if entry.owner&.name == ancestor
-              resolved_alias = resolve_method_alias(entry, receiver_name)
+              resolved_alias = resolve_method_alias(entry, receiver_name, seen_names)
               resolved_alias if resolved_alias.is_a?(Entry::MethodAlias)
             end
           end
@@ -605,7 +608,7 @@ module RubyIndexer
           attached_ancestor.file_path,
           attached_ancestor.location,
           attached_ancestor.name_location,
-          [],
+          nil,
           nil,
         )
         add(singleton, skip_prefix_tree: true)
@@ -614,6 +617,17 @@ module RubyIndexer
       singleton
     end
 
+    sig do
+      type_parameters(:T).params(
+        path: String,
+        type: T::Class[T.all(T.type_parameter(:T), Entry)],
+      ).returns(T.nilable(T::Array[T.type_parameter(:T)]))
+    end
+    def entries_for(path, type)
+      entries = @files_to_entries[path]
+      entries&.grep(type)
+    end
+
     private
 
     # Runs the registered included hooks
@@ -919,16 +933,21 @@ module RubyIndexer
       params(
         entry: Entry::UnresolvedMethodAlias,
         receiver_name: String,
+        seen_names: T::Array[String],
       ).returns(T.any(Entry::MethodAlias, Entry::UnresolvedMethodAlias))
     end
-    def resolve_method_alias(entry, receiver_name)
-      return entry if entry.new_name == entry.old_name
+    def resolve_method_alias(entry, receiver_name, seen_names)
+      new_name = entry.new_name
+      return entry if new_name == entry.old_name
+      return entry if seen_names.include?(new_name)
+
+      seen_names << new_name
 
-      target_method_entries = resolve_method(entry.old_name, receiver_name)
+      target_method_entries = resolve_method(entry.old_name, receiver_name, seen_names)
       return entry unless target_method_entries
 
       resolved_alias = Entry::MethodAlias.new(T.must(target_method_entries.first), entry)
-      original_entries = T.must(@entries[entry.new_name])
+      original_entries = T.must(@entries[new_name])
       original_entries.delete(entry)
       original_entries << resolved_alias
       resolved_alias

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