ruby-lsp 0.14.5 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '046081e0caf521f948f3952bd7a356ef6f0beb80c5a9ff72930a6d0c9fd8d9f4'
-  data.tar.gz: e65b5224342c412a0b28198af0e56b17a421eaacc7748a17d2ed30890c0a2d86
+  metadata.gz: 9749ddfd5f25d0f6e3c0636a070d8977c19af973943e33deba4e49cba9b473d6
+  data.tar.gz: 1c3f663fd6487e8517154a2595be253659e2f2f9bd6a4df23c8b16a91e159c4d
 SHA512:
-  metadata.gz: 682219fbef2c6e1483c0e6b0c36bf2ce8c3bd15aed88e53ee1a05623f5569c7e52227300b1a6fb4968a6ba2b0844a7e985a0b134af9e9498036199673d660117
-  data.tar.gz: a13eb33a1a41514819f4d0612a5d50eb170a0adb36158b799cebffae34781a5d41c1b07922f0bec8310cf6439ea8356305224bcf1de7423b96ff6e28c9e744c8
+  metadata.gz: '039fc58aa31af82930cc2852819208fdd9045ed493cf368702f87e9ffd814487bf63fe522124fa3210336cfc72d806b828e2e338114a66913dbd688ed85980c3'
+  data.tar.gz: bb4d62e3ce21fe07cda085f0284b69c356a10694125454b8160bd0c5e87789481b2d4f8036cdb4cdc2b0667c8a78c7e7a1409307722a532122172fcff8c5450c

data/VERSION

@@ -1 +1 @@
-0.14.5
+0.15.0

data/exe/ruby-lsp

@@ -68,22 +68,7 @@ if ENV["BUNDLE_GEMFILE"].nil?
   exit exec(env, "bundle exec ruby-lsp #{original_args.join(" ")}")
 end
 
-require "sorbet-runtime"
-
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*) {}
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
-end
+require "ruby_lsp/load_sorbet"
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"

data/exe/ruby-lsp-check

@@ -3,16 +3,7 @@
 
 # This executable checks if all automatic LSP requests run successfully on every Ruby file under the current directory
 
-require "sorbet-runtime"
-
-begin
-  T::Configuration.default_checked_level = :never
-  T::Configuration.call_validation_error_handler = ->(*) {}
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  nil
-end
+require "ruby_lsp/load_sorbet"
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
@@ -24,30 +15,30 @@ files = Dir.glob("#{Dir.pwd}/**/*.rb")
 puts "Verifying that all automatic LSP requests execute successfully. This may take a while..."
 
 errors = {}
-store = RubyLsp::Store.new
-message_queue = Thread::Queue.new
-RubyLsp::Addon.load_addons(message_queue)
-executor = RubyLsp::Executor.new(store, message_queue)
+server = RubyLsp::Server.new(test_mode: true)
 
 files.each_with_index do |file, index|
   uri = URI("file://#{file}")
-  store.set(uri: uri, source: File.read(file), version: 1)
+  server.process_message({
+    method: "textDocument/didOpen",
+    params: { textDocument: { uri: uri, text: File.read(file), version: 1 } },
+  })
 
   # Executing any of the automatic requests will execute all of them, so here we just pick one
-  result = executor.execute({
+  server.process_message({
+    id: 1,
     method: "textDocument/documentSymbol",
-    params: { textDocument: { uri: uri.to_s } },
+    params: { textDocument: { uri: uri } },
   })
 
-  error = result.error
-  errors[file] = error if error
+  result = server.pop_response
+  errors[file] = result.message if result.is_a?(RubyLsp::Error)
 ensure
-  store.delete(uri)
+  server.process_message({ method: "textDocument/didClose", params: { textDocument: { uri: uri } } })
+  server.pop_response
   print("\033[M\033[0KCompleted #{index + 1}/#{files.length}") unless ENV["CI"]
 end
-
 puts "\n"
-message_queue.close
 
 # Indexing
 puts "Verifying that indexing executes successfully. This may take a while..."

data/lib/ruby_indexer/lib/ruby_indexer/collector.rb

@@ -152,6 +152,8 @@ module RubyIndexer
         handle_attribute(node, reader: false, writer: true)
       when :attr_accessor
         handle_attribute(node, reader: true, writer: true)
+      when :include
+        handle_include(node)
       end
     end
 
@@ -350,5 +352,24 @@ module RubyIndexer
         @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
       end
     end
+
+    sig { params(node: Prism::CallNode).void }
+    def handle_include(node)
+      return unless @current_owner
+
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      names = arguments.filter_map do |node|
+        if node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+          node.full_name
+        end
+      rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+        # TO DO: add MissingNodesInConstantPathError when released in Prism
+        # If a constant path reference is dynamic or missing parts, we can't
+        # index it
+      end
+      @current_owner.included_modules.concat(names)
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -20,7 +20,7 @@ module RubyIndexer
     def initialize
       @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
       @included_gems = T.let([], T::Array[String])
-      @excluded_patterns = T.let([File.join("**", "*_test.rb")], T::Array[String])
+      @excluded_patterns = T.let([File.join("**", "*_test.rb"), File.join("**", "tmp", "**", "*")], T::Array[String])
       path = Bundler.settings["path"]
       @excluded_patterns << File.join(File.expand_path(path, Dir.pwd), "**", "*.rb") if path
 
@@ -43,20 +43,6 @@ module RubyIndexer
       )
     end
 
-    sig { void }
-    def load_config
-      return unless File.exist?(".index.yml")
-
-      config = YAML.parse_file(".index.yml")
-      return unless config
-
-      config_hash = config.to_ruby
-      validate_config!(config_hash)
-      apply_config(config_hash)
-    rescue Psych::SyntaxError => e
-      raise e, "Syntax error while loading .index.yml configuration: #{e.message}"
-    end
-
     sig { returns(T::Array[IndexablePath]) }
     def indexables
       excluded_gems = @excluded_gems - @included_gems
@@ -158,6 +144,17 @@ module RubyIndexer
       @magic_comment_regex ||= T.let(/^#\s*#{@excluded_magic_comments.join("|")}/, T.nilable(Regexp))
     end
 
+    sig { params(config: T::Hash[String, T.untyped]).void }
+    def apply_config(config)
+      validate_config!(config)
+
+      @excluded_gems.concat(config["excluded_gems"]) if config["excluded_gems"]
+      @included_gems.concat(config["included_gems"]) if config["included_gems"]
+      @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
+      @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
+      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
+    end
+
     private
 
     sig { params(config: T::Hash[String, T.untyped]).void }
@@ -175,15 +172,6 @@ module RubyIndexer
       raise ArgumentError, errors.join("\n") if errors.any?
     end
 
-    sig { params(config: T::Hash[String, T.untyped]).void }
-    def apply_config(config)
-      @excluded_gems.concat(config["excluded_gems"]) if config["excluded_gems"]
-      @included_gems.concat(config["included_gems"]) if config["included_gems"]
-      @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
-      @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
-      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
-    end
-
     sig { returns(T::Array[String]) }
     def initial_excluded_gems
       excluded, others = Bundler.definition.dependencies.partition do |dependency|

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

@@ -40,6 +40,22 @@ module RubyIndexer
 
       abstract!
 
+      sig { returns(T::Array[String]) }
+      attr_accessor :included_modules
+
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+        ).void
+      end
+      def initialize(name, file_path, location, comments)
+        super(name, file_path, location, comments)
+        @included_modules = T.let([], T::Array[String])
+      end
+
       sig { returns(String) }
       def short_name
         T.must(@name.split("::").last)

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

@@ -191,8 +191,9 @@ module RubyIndexer
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
-    rescue Errno::EISDIR
-      # If `path` is a directory, just ignore it and continue indexing
+    rescue Errno::EISDIR, Errno::ENOENT
+      # If `path` is a directory, just ignore it and continue indexing. If the file doesn't exist, then we also ignore
+      # it
     end
 
     # Follows aliases in a namespace. The algorithm keeps checking if the name is an alias and then recursively follows

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -281,5 +281,51 @@ module RubyIndexer
       final_thing = T.must(@index["FinalThing"].first)
       assert_equal("Something::Baz", final_thing.parent_class)
     end
+
+    def test_keeping_track_of_included_modules
+      index(<<~RUBY)
+        class Foo
+          # valid syntaxes that we can index
+          include A1
+          self.include A2
+          include A3, A4
+          self.include A5, A6
+
+          # valid syntaxes that we cannot index because of their dynamic nature
+          include some_variable_or_method_call
+          self.include some_variable_or_method_call
+
+          def something
+            include A7 # We should not index this because of this dynamic nature
+          end
+
+          # Valid inner class syntax definition with its own modules included
+          class Qux
+            include Corge
+            self.include Corge
+            include Baz
+
+            include some_variable_or_method_call
+          end
+        end
+
+        class ConstantPathReferences
+          include Foo::Bar
+          self.include Foo::Bar2
+
+          include dynamic::Bar
+          include Foo::
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"][0])
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.included_modules)
+
+      qux = T.must(@index["Foo::Qux"][0])
+      assert_equal(["Corge", "Corge", "Baz"], qux.included_modules)
+
+      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.included_modules)
+    end
   end
 end

data/lib/ruby_indexer/test/configuration_test.rb

@@ -10,7 +10,7 @@ module RubyIndexer
     end
 
     def test_load_configuration_executes_configure_block
-      @config.load_config
+      @config.apply_config({ "excluded_patterns" => ["**/test/fixtures/**/*.rb"] })
       indexables = @config.indexables
 
       assert(indexables.none? { |indexable| indexable.full_path.include?("test/fixtures") })
@@ -21,7 +21,6 @@ module RubyIndexer
     end
 
     def test_indexables_only_includes_gem_require_paths
-      @config.load_config
       indexables = @config.indexables
 
       Bundler.locked_gems.specs.each do |lazy_spec|
@@ -35,7 +34,6 @@ module RubyIndexer
     end
 
     def test_indexables_does_not_include_default_gem_path_when_in_bundle
-      @config.load_config
       indexables = @config.indexables
 
       assert(
@@ -44,7 +42,6 @@ module RubyIndexer
     end
 
     def test_indexables_includes_default_gems
-      @config.load_config
       indexables = @config.indexables.map(&:full_path)
 
       assert_includes(indexables, "#{RbConfig::CONFIG["rubylibdir"]}/pathname.rb")
@@ -53,7 +50,6 @@ module RubyIndexer
     end
 
     def test_indexables_includes_project_files
-      @config.load_config
       indexables = @config.indexables.map(&:full_path)
 
       Dir.glob("#{Dir.pwd}/lib/**/*.rb").each do |path|
@@ -66,7 +62,6 @@ module RubyIndexer
     def test_indexables_avoids_duplicates_if_bundle_path_is_inside_project
       Bundler.settings.set_global("path", "vendor/bundle")
       config = Configuration.new
-      config.load_config
 
       assert_includes(config.instance_variable_get(:@excluded_patterns), "#{Dir.pwd}/vendor/bundle/**/*.rb")
     ensure
@@ -74,7 +69,6 @@ module RubyIndexer
     end
 
     def test_indexables_does_not_include_gems_own_installed_files
-      @config.load_config
       indexables = @config.indexables
 
       assert(
@@ -95,17 +89,14 @@ module RubyIndexer
     end
 
     def test_paths_are_unique
-      @config.load_config
       indexables = @config.indexables
 
       assert_equal(indexables.uniq.length, indexables.length)
     end
 
     def test_configuration_raises_for_unknown_keys
-      Psych::Nodes::Document.any_instance.expects(:to_ruby).returns({ "unknown_config" => 123 })
-
       assert_raises(ArgumentError) do
-        @config.load_config
+        @config.apply_config({ "unknown_config" => 123 })
       end
     end
 

data/lib/ruby_indexer/test/index_test.rb

@@ -308,5 +308,10 @@ module RubyIndexer
 
       refute_empty(@index.instance_variable_get(:@entries))
     end
+
+    def test_index_single_does_not_fail_for_non_existing_file
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"))
+      assert_empty(@index.instance_variable_get(:@entries))
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -121,22 +121,23 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+        global_state: GlobalState,
         uri: URI::Generic,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_code_lens_listener(response_builder, uri, dispatcher); end
+    def create_code_lens_listener(response_builder, global_state, uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do
       overridable.params(
         response_builder: ResponseBuilders::Hover,
+        global_state: GlobalState,
         nesting: T::Array[String],
-        index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_hover_listener(response_builder, nesting, index, dispatcher); end
+    def create_hover_listener(response_builder, global_state, nesting, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
@@ -159,12 +160,24 @@ module RubyLsp
     sig do
       overridable.params(
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+        global_state: GlobalState,
         uri: URI::Generic,
         nesting: T::Array[String],
-        index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
       ).void
     end
-    def create_definition_listener(response_builder, uri, nesting, index, dispatcher); end
+    def create_definition_listener(response_builder, global_state, uri, nesting, dispatcher); end
+
+    # Creates a new Completion listener. This method is invoked on every Completion request
+    sig do
+      overridable.params(
+        response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
+        global_state: GlobalState,
+        nesting: T::Array[String],
+        dispatcher: Prism::Dispatcher,
+        uri: URI::Generic,
+      ).void
+    end
+    def create_completion_listener(response_builder, global_state, nesting, dispatcher, uri); end
   end
 end

data/lib/ruby_lsp/base_server.rb

@@ -0,0 +1,147 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class BaseServer
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { params(test_mode: T::Boolean).void }
+    def initialize(test_mode: false)
+      @test_mode = T.let(test_mode, T::Boolean)
+      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
+      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
+      @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
+      @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
+      @cancelled_requests = T.let([], T::Array[Integer])
+      @mutex = T.let(Mutex.new, Mutex)
+      @worker = T.let(new_worker, Thread)
+      @current_request_id = T.let(1, Integer)
+      @store = T.let(Store.new, Store)
+      @outgoing_dispatcher = T.let(
+        Thread.new do
+          unless test_mode
+            while (message = @outgoing_queue.pop)
+              @mutex.synchronize { @writer.write(message.to_hash) }
+            end
+          end
+        end,
+        Thread,
+      )
+
+      Thread.main.priority = 1
+    end
+
+    sig { void }
+    def start
+      @reader.read do |message|
+        method = message[:method]
+
+        # We must parse the document under a mutex lock or else we might switch threads and accept text edits in the
+        # source. Altering the source reference during parsing will put the parser in an invalid internal state, since
+        # it started parsing with one source but then it changed in the middle. We don't want to do this for text
+        # synchronization notifications
+        @mutex.synchronize do
+          uri = message.dig(:params, :textDocument, :uri)
+
+          if uri
+            begin
+              parsed_uri = URI(uri)
+              message[:params][:textDocument][:uri] = parsed_uri
+
+              # We don't want to try to parse documents on text synchronization notifications
+              @store.get(parsed_uri).parse unless method.start_with?("textDocument/did")
+            rescue Errno::ENOENT
+              # If we receive a request for a file that no longer exists, we don't want to fail
+            end
+          end
+        end
+
+        # We need to process shutdown and exit from the main thread in order to close queues and wait for other threads
+        # to finish. Everything else is pushed into the incoming queue
+        case method
+        when "shutdown"
+          $stderr.puts("Shutting down Ruby LSP...")
+
+          shutdown
+
+          @mutex.synchronize do
+            run_shutdown
+            @writer.write(Result.new(id: message[:id], response: nil).to_hash)
+          end
+        when "exit"
+          @mutex.synchronize do
+            status = @incoming_queue.closed? ? 0 : 1
+            $stderr.puts("Shutdown complete with status #{status}")
+            exit(status)
+          end
+        else
+          @incoming_queue << message
+        end
+      end
+    end
+
+    sig { void }
+    def run_shutdown
+      @incoming_queue.clear
+      @outgoing_queue.clear
+      @incoming_queue.close
+      @outgoing_queue.close
+      @cancelled_requests.clear
+
+      @worker.join
+      @outgoing_dispatcher.join
+      @store.clear
+    end
+
+    # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
+    sig { returns(T.untyped) }
+    def pop_response
+      @outgoing_queue.pop
+    end
+
+    sig { abstract.params(message: T::Hash[Symbol, T.untyped]).void }
+    def process_message(message); end
+
+    sig { abstract.void }
+    def shutdown; end
+
+    sig { returns(Thread) }
+    def new_worker
+      Thread.new do
+        while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
+          id = message[:id]
+
+          # Check if the request was cancelled before trying to process it
+          @mutex.synchronize do
+            if id && @cancelled_requests.include?(id)
+              send_message(Result.new(id: id, response: nil))
+              @cancelled_requests.delete(id)
+              next
+            end
+          end
+
+          process_message(message)
+        end
+      end
+    end
+
+    sig { params(message: T.any(Result, Error, Notification, Request)).void }
+    def send_message(message)
+      # When we're shutting down the server, there's a small race condition between closing the thread queues and
+      # finishing remaining requests. We may close the queue in the middle of processing a request, which will then fail
+      # when trying to send a response back
+      return if @outgoing_queue.closed?
+
+      @outgoing_queue << message
+      @current_request_id += 1 if message.is_a?(Request)
+    end
+
+    sig { params(id: Integer).void }
+    def send_empty_response(id)
+      send_message(Result.new(id: id, response: nil))
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -180,11 +180,6 @@ module RubyLsp
       end
     end
 
-    sig { returns(T::Boolean) }
-    def typechecker_enabled?
-      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
-    end
-
     class Scanner
       extend T::Sig
 

data/lib/ruby_lsp/{requests/support/dependency_detector.rb → global_state.rb}

@@ -1,27 +1,41 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "singleton"
-
 module RubyLsp
-  class DependencyDetector
-    include Singleton
+  class GlobalState
     extend T::Sig
 
     sig { returns(String) }
-    attr_reader :detected_formatter
+    attr_reader :test_library
 
     sig { returns(String) }
-    attr_reader :detected_test_library
+    attr_accessor :formatter
 
     sig { returns(T::Boolean) }
     attr_reader :typechecker
 
+    sig { returns(RubyIndexer::Index) }
+    attr_reader :index
+
     sig { void }
     def initialize
-      @detected_formatter = T.let(detect_formatter, String)
-      @detected_test_library = T.let(detect_test_library, String)
+      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
+
+      @formatter = T.let(detect_formatter, String)
+      @test_library = T.let(detect_test_library, String)
       @typechecker = T.let(detect_typechecker, T::Boolean)
+      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
+    end
+
+    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    def apply_options(options)
+      workspace_uri = options.dig(:workspaceFolders, 0, :uri)
+      @workspace_uri = URI(workspace_uri) if workspace_uri
+    end
+
+    sig { returns(String) }
+    def workspace_path
+      T.must(@workspace_uri.to_standardized_path)
     end
 
     sig { returns(String) }
@@ -63,8 +77,15 @@ module RubyLsp
     def detect_typechecker
       return false if ENV["RUBY_LSP_BYPASS_TYPECHECKER"]
 
+      # We can't read the env from within `Bundle.with_original_env` so we need to set it here.
+      ruby_lsp_env_is_test = (ENV["RUBY_LSP_ENV"] == "test")
       Bundler.with_original_env do
-        Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+        sorbet_static_detected = Bundler.locked_gems.specs.any? { |spec| spec.name == "sorbet-static" }
+        # Don't show message while running tests, since it's noisy
+        if sorbet_static_detected && !ruby_lsp_env_is_test
+          $stderr.puts("Ruby LSP detected this is a Sorbet project so will defer to Sorbet LSP for some functionality")
+        end
+        sorbet_static_detected
       end
     rescue Bundler::GemfileNotFound
       false

data/lib/ruby_lsp/internal.rb

@@ -20,12 +20,13 @@ require "prism/visitor"
 require "language_server-protocol"
 
 require "ruby-lsp"
+require "ruby_lsp/base_server"
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/parameter_scope"
+require "ruby_lsp/global_state"
 require "ruby_lsp/server"
-require "ruby_lsp/executor"
 require "ruby_lsp/requests"
 require "ruby_lsp/response_builders"
 require "ruby_lsp/document"