ruby-lsp 0.18.1 → 0.18.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42aef038c33d8c03d661dc1c39c745df320399ab86e6c558504c79c93bac4952
-  data.tar.gz: ff4ce59697e498c965a0db7b8df44de12e4c81cebb6ef84d50cc54664647f913
+  metadata.gz: d78954c10106529d35716e266769c1ddf6bf8235d7441c881aaa2f06cb757956
+  data.tar.gz: 14a40cc3212ce2c90ad23f099b44b0a8aa75a0cf40445b6b2a9b74048cb18794
 SHA512:
-  metadata.gz: 1a88854595b50bab0ede9aaaa40fe8d765afb6f8744246c8d3407769ad981d00579b20a52f61c4f2c929d8ecdd3578625093b41cf30f6c7224ac64117a201b39
-  data.tar.gz: 9093a75fbecd3349e0b6bd80bc899928ea40a4afb2c2a1ae64a5be1bde84bf800280a24910a35ff7eac3b7e470785a649a370214f9f51b8bbd898ede81e09903
+  metadata.gz: 2320f897c2895afa3cd710c10f5bc5bf238c9a53eb39a38071887cd475198fd4c6f60020d71d62405579ff3ebe5ea0bd9b1d8e02599d5107b35ca6fe17789397
+  data.tar.gz: 8e31ed714b473b46791dda5c3e83e68d4e0756dc2980f0e6c34b8652337278a928e104566be12a933ffae1525533b8935651c45580b07f95cab4ac732965a348

data/VERSION

@@ -1 +1 @@
-0.18.1
+0.18.2

data/exe/ruby-lsp

@@ -29,13 +29,6 @@ parser = OptionParser.new do |opts|
     options[:branch] = branch
   end
 
-  opts.on(
-    "--experimental",
-    "Run pre-release versions of the Ruby LSP",
-  ) do
-    options[:experimental] = true
-  end
-
   opts.on("--doctor", "Run troubleshooting steps") do
     options[:doctor] = true
   end

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:
     #
@@ -365,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
 
@@ -824,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 -
@@ -871,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/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_lsp/internal.rb

@@ -30,8 +30,6 @@ require "ruby_lsp/parameter_scope"
 require "ruby_lsp/global_state"
 require "ruby_lsp/server"
 require "ruby_lsp/type_inferrer"
-require "ruby_lsp/requests"
-require "ruby_lsp/response_builders"
 require "ruby_lsp/node_context"
 require "ruby_lsp/document"
 require "ruby_lsp/ruby_document"
@@ -39,6 +37,47 @@ require "ruby_lsp/erb_document"
 require "ruby_lsp/rbs_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
+
+# Response builders
+require "ruby_lsp/response_builders/response_builder"
+require "ruby_lsp/response_builders/collection_response_builder"
+require "ruby_lsp/response_builders/document_symbol"
+require "ruby_lsp/response_builders/hover"
+require "ruby_lsp/response_builders/semantic_highlighting"
+require "ruby_lsp/response_builders/signature_help"
+
+# Request support
+require "ruby_lsp/requests/support/rubocop_diagnostic"
+require "ruby_lsp/requests/support/selection_range"
+require "ruby_lsp/requests/support/annotation"
+require "ruby_lsp/requests/support/sorbet"
+require "ruby_lsp/requests/support/common"
+require "ruby_lsp/requests/support/formatter"
 require "ruby_lsp/requests/support/rubocop_runner"
 require "ruby_lsp/requests/support/rubocop_formatter"
 require "ruby_lsp/requests/support/syntax_tree_formatter"
+
+# Requests
+require "ruby_lsp/requests/request"
+require "ruby_lsp/requests/code_action_resolve"
+require "ruby_lsp/requests/code_actions"
+require "ruby_lsp/requests/code_lens"
+require "ruby_lsp/requests/completion_resolve"
+require "ruby_lsp/requests/completion"
+require "ruby_lsp/requests/definition"
+require "ruby_lsp/requests/diagnostics"
+require "ruby_lsp/requests/document_highlight"
+require "ruby_lsp/requests/document_link"
+require "ruby_lsp/requests/document_symbol"
+require "ruby_lsp/requests/folding_ranges"
+require "ruby_lsp/requests/formatting"
+require "ruby_lsp/requests/hover"
+require "ruby_lsp/requests/inlay_hints"
+require "ruby_lsp/requests/on_type_formatting"
+require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/selection_ranges"
+require "ruby_lsp/requests/semantic_highlighting"
+require "ruby_lsp/requests/show_syntax_tree"
+require "ruby_lsp/requests/signature_help"
+require "ruby_lsp/requests/type_hierarchy_supertypes"
+require "ruby_lsp/requests/workspace_symbol"

data/lib/ruby_lsp/listeners/completion.rb

@@ -104,7 +104,7 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
-        candidates = @index.prefix_search(name, @node_context.nesting)
+        candidates = @index.constant_completion_candidates(name, @node_context.nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
           @response_builder << build_entry_completion(
@@ -124,7 +124,13 @@ module RubyLsp
         # no sigil, Sorbet will still provide completion for constants
         return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
-        name = constant_name(node)
+        name = begin
+          node.full_name
+        rescue Prism::ConstantPathNode::MissingNodesInConstantPathError
+          node.slice
+        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+          nil
+        end
         return if name.nil?
 
         constant_path_completion(name, range_from_location(node.location))
@@ -230,7 +236,7 @@ module RubyLsp
 
         real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
-        candidates = @index.prefix_search(
+        candidates = @index.constant_completion_candidates(
           "#{real_namespace}::#{incomplete_name}",
           top_level_reference ? [] : nesting,
         )
@@ -240,8 +246,16 @@ module RubyLsp
           first_entry = T.must(entries.first)
           next if first_entry.private? && !first_entry.name.start_with?("#{nesting}::")
 
-          constant_name = first_entry.name.delete_prefix("#{real_namespace}::")
-          full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
+          entry_name = first_entry.name
+          full_name = if aliased_namespace != real_namespace
+            constant_name = entry_name.delete_prefix("#{real_namespace}::")
+            aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
+          elsif !entry_name.start_with?(aliased_namespace)
+            *_, short_name = entry_name.split("::")
+            "#{aliased_namespace}::#{short_name}"
+          else
+            entry_name
+          end
 
           @response_builder << build_entry_completion(
             full_name,
@@ -545,7 +559,7 @@ module RubyLsp
       sig { params(entry_name: String).returns(T::Boolean) }
       def top_level?(entry_name)
         nesting = @node_context.nesting
-        nesting.length.downto(0).each do |i|
+        nesting.length.downto(0) do |i|
           prefix = T.must(nesting[0...i]).join("::")
           full_name = prefix.empty? ? entry_name : "#{prefix}::#{entry_name}"
           next if full_name == entry_name

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -12,14 +12,12 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
-          range: T::Range[Integer],
           hints_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, range, hints_configuration, dispatcher)
+      def initialize(response_builder, hints_configuration, dispatcher)
         @response_builder = response_builder
-        @range = range
         @hints_configuration = hints_configuration
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
@@ -31,7 +29,6 @@ module RubyLsp
         return unless node.exceptions.empty?
 
         loc = node.location
-        return unless visible?(node, @range)
 
         @response_builder << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
@@ -44,7 +41,6 @@ module RubyLsp
       sig { params(node: Prism::ImplicitNode).void }
       def on_implicit_node_enter(node)
         return unless @hints_configuration.enabled?(:implicitHashValue)
-        return unless visible?(node, @range)
 
         node_value = node.value
         loc = node.location
@@ -69,17 +65,6 @@ module RubyLsp
           tooltip: tooltip,
         )
       end
-
-      private
-
-      sig { params(node: T.nilable(Prism::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
-      def visible?(node, range)
-        return true if range.nil?
-        return false if node.nil?
-
-        loc = node.location
-        range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -46,8 +46,8 @@ module RubyLsp
 
         if owner_name
           entries = entries.select do |entry|
-            (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable)) &&
-              entry.owner&.name == owner_name
+            (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable) ||
+            entry.is_a?(RubyIndexer::Entry::MethodAlias)) && entry.owner&.name == owner_name
           end
         end
 

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -23,21 +23,18 @@ module RubyLsp
       sig do
         params(
           document: T.any(RubyDocument, ERBDocument),
-          range: T::Hash[Symbol, T.untyped],
           hints_configuration: RequestConfig,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, range, hints_configuration, dispatcher)
+      def initialize(document, hints_configuration, dispatcher)
         super()
-        start_line = range.dig(:start, :line)
-        end_line = range.dig(:end, :line)
 
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
         )
-        Listeners::InlayHints.new(@response_builder, start_line..end_line, hints_configuration, dispatcher)
+        Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
       end
 
       sig { override.returns(T::Array[Interface::InlayHint]) }

data/lib/ruby_lsp/server.rb

@@ -411,6 +411,7 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
+      inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
       dispatcher.dispatch(parse_result.value)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -419,6 +420,7 @@ module RubyLsp
       document.cache_set("textDocument/documentSymbol", document_symbol.perform)
       document.cache_set("textDocument/documentLink", document_link.perform)
       document.cache_set("textDocument/codeLens", code_lens.perform)
+      document.cache_set("textDocument/inlayHint", inlay_hint.perform)
 
       send_message(Result.new(id: message[:id], response: document.cache_get(message[:method])))
     end
@@ -611,18 +613,35 @@ module RubyLsp
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_inlay_hint(message)
       params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+      range = params.dig(:range, :start, :line)..params.dig(:range, :end, :line)
+
+      cached_response = document.cache_get("textDocument/inlayHint")
+      if cached_response != Document::EMPTY_CACHE
+
+        send_message(
+          Result.new(
+            id: message[:id],
+            response: cached_response.select { |hint| range.cover?(hint.position[:line]) },
+          ),
+        )
+        return
+      end
+
       hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
       dispatcher = Prism::Dispatcher.new
-      document = @store.get(params.dig(:textDocument, :uri))
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
         send_empty_response(message[:id])
         return
       end
 
-      request = Requests::InlayHints.new(document, params[:range], hints_configurations, dispatcher)
+      request = Requests::InlayHints.new(document, hints_configurations, dispatcher)
       dispatcher.visit(document.parse_result.value)
-      send_message(Result.new(id: message[:id], response: request.perform))
+      result = request.perform
+      document.cache_set("textDocument/inlayHint", result)
+
+      send_message(Result.new(id: message[:id], response: result.select { |hint| range.cover?(hint.position[:line]) }))
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }

data/lib/ruby_lsp/setup_bundler.rb

@@ -27,7 +27,6 @@ module RubyLsp
     def initialize(project_path, **options)
       @project_path = project_path
       @branch = T.let(options[:branch], T.nilable(String))
-      @experimental = T.let(options[:experimental], T.nilable(T::Boolean))
 
       # Regular bundle paths
       @gemfile = T.let(
@@ -207,7 +206,6 @@ module RubyLsp
         command << "ruby-lsp " unless @dependencies["ruby-lsp"]
         command << "debug " unless @dependencies["debug"]
         command << "ruby-lsp-rails " if @rails_app && !@dependencies["ruby-lsp-rails"]
-        command << "--pre" if @experimental
         command.delete_suffix!(" ")
         command << ")"
 
@@ -255,7 +253,9 @@ module RubyLsp
       # "vendor/bundle"`
       settings.all.to_h do |e|
         key = Bundler::Settings.key_for(e)
-        [key, settings[e].to_s]
+        value = Array(settings[e]).join(":").tr(" ", ":")
+
+        [key, value]
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.18.2
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-20 00:00:00.000000000 Z
+date: 2024-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -131,7 +131,6 @@ files:
 - lib/ruby_lsp/node_context.rb
 - lib/ruby_lsp/parameter_scope.rb
 - lib/ruby_lsp/rbs_document.rb
-- lib/ruby_lsp/requests.rb
 - lib/ruby_lsp/requests/code_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
 - lib/ruby_lsp/requests/code_lens.rb
@@ -165,7 +164,6 @@ files:
 - lib/ruby_lsp/requests/support/syntax_tree_formatter.rb
 - lib/ruby_lsp/requests/type_hierarchy_supertypes.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
-- lib/ruby_lsp/response_builders.rb
 - lib/ruby_lsp/response_builders/collection_response_builder.rb
 - lib/ruby_lsp/response_builders/document_symbol.rb
 - lib/ruby_lsp/response_builders/hover.rb

data/lib/ruby_lsp/requests.rb

@@ -1,64 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # Supported features
-  #
-  # - [DocumentSymbol](rdoc-ref:RubyLsp::Requests::DocumentSymbol)
-  # - [DocumentLink](rdoc-ref:RubyLsp::Requests::DocumentLink)
-  # - [Hover](rdoc-ref:RubyLsp::Requests::Hover)
-  # - [FoldingRange](rdoc-ref:RubyLsp::Requests::FoldingRanges)
-  # - [SelectionRange](rdoc-ref:RubyLsp::Requests::SelectionRanges)
-  # - [SemanticHighlighting](rdoc-ref:RubyLsp::Requests::SemanticHighlighting)
-  # - [Formatting](rdoc-ref:RubyLsp::Requests::Formatting)
-  # - [OnTypeFormatting](rdoc-ref:RubyLsp::Requests::OnTypeFormatting)
-  # - [Diagnostic](rdoc-ref:RubyLsp::Requests::Diagnostics)
-  # - [CodeAction](rdoc-ref:RubyLsp::Requests::CodeActions)
-  # - [CodeActionResolve](rdoc-ref:RubyLsp::Requests::CodeActionResolve)
-  # - [DocumentHighlight](rdoc-ref:RubyLsp::Requests::DocumentHighlight)
-  # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
-  # - [Completion](rdoc-ref:RubyLsp::Requests::Completion)
-  # - [CompletionResolve](rdoc-ref:RubyLsp::Requests::CompletionResolve)
-  # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
-  # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
-  # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
-  # - [WorkspaceSymbol](rdoc-ref:RubyLsp::Requests::WorkspaceSymbol)
-  # - [SignatureHelp](rdoc-ref:RubyLsp::Requests::SignatureHelp)
-
-  module Requests
-    autoload :Request, "ruby_lsp/requests/request"
-    autoload :DocumentSymbol, "ruby_lsp/requests/document_symbol"
-    autoload :DocumentLink, "ruby_lsp/requests/document_link"
-    autoload :Hover, "ruby_lsp/requests/hover"
-    autoload :FoldingRanges, "ruby_lsp/requests/folding_ranges"
-    autoload :SelectionRanges, "ruby_lsp/requests/selection_ranges"
-    autoload :SemanticHighlighting, "ruby_lsp/requests/semantic_highlighting"
-    autoload :Formatting, "ruby_lsp/requests/formatting"
-    autoload :OnTypeFormatting, "ruby_lsp/requests/on_type_formatting"
-    autoload :Diagnostics, "ruby_lsp/requests/diagnostics"
-    autoload :CodeActions, "ruby_lsp/requests/code_actions"
-    autoload :CodeActionResolve, "ruby_lsp/requests/code_action_resolve"
-    autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
-    autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
-    autoload :Completion, "ruby_lsp/requests/completion"
-    autoload :CompletionResolve, "ruby_lsp/requests/completion_resolve"
-    autoload :CodeLens, "ruby_lsp/requests/code_lens"
-    autoload :Definition, "ruby_lsp/requests/definition"
-    autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
-    autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
-    autoload :SignatureHelp, "ruby_lsp/requests/signature_help"
-    autoload :PrepareTypeHierarchy, "ruby_lsp/requests/prepare_type_hierarchy"
-    autoload :TypeHierarchySupertypes, "ruby_lsp/requests/type_hierarchy_supertypes"
-
-    # :nodoc:
-    module Support
-      autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
-      autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
-      autoload :Annotation, "ruby_lsp/requests/support/annotation"
-      autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
-      autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
-      autoload :Common, "ruby_lsp/requests/support/common"
-      autoload :Formatter, "ruby_lsp/requests/support/formatter"
-    end
-  end
-end

data/lib/ruby_lsp/response_builders.rb

@@ -1,13 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module ResponseBuilders
-    autoload :CollectionResponseBuilder, "ruby_lsp/response_builders/collection_response_builder"
-    autoload :DocumentSymbol, "ruby_lsp/response_builders/document_symbol"
-    autoload :Hover, "ruby_lsp/response_builders/hover"
-    autoload :ResponseBuilder, "ruby_lsp/response_builders/response_builder"
-    autoload :SemanticHighlighting, "ruby_lsp/response_builders/semantic_highlighting"
-    autoload :SignatureHelp, "ruby_lsp/response_builders/signature_help"
-  end
-end