ruby-lsp 0.14.6 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c364aee0d80e6187f66e8eb6d50d7cdd21ffb129e0a0b17c9dc7bd5d8a18cad
-  data.tar.gz: 65964ec1d89f10adf9bcbf113efed6d43a977b669abe51182e90dd9870032623
+  metadata.gz: faf267ef6ce1eb7c9471d0a63b07c8da3d60ae1aeb656b63eedb64c493746e18
+  data.tar.gz: 56cd98100e674d8e3de391cb107efb7c4b713715494f212f879e687d2c26cda4
 SHA512:
-  metadata.gz: 971af8a3c02903597143a8ec49915eead6bc0f65a0175e4a443e381d671dd4a88f776a26f62af1bd69ee7dc3f478b36bef122febbfaed7656907eb1a6a7a3354
-  data.tar.gz: 15148c1c3765390f9bb92dbafe7043ac15b22de6b5c415c424a063f4742026d92831d84bcde2013ab742c4a889dc16d666d4ec5d18863d0db8acf793ce87f0a6
+  metadata.gz: 75077a56844015e9915c1232102eca5e5bcc40687207579367b9ce836525a369e4d87e2a3e89223ca4af3bad1b8fdf09648d2839a756d171fefdc2c7d38c9df4
+  data.tar.gz: '025321865d6799a4ca874296d2552d8ec71f7ffa3023a104f74633ae9b858ab757dd5babee429aa38b04c1820ce64c4f7416aa626267189ac43d262744698369'

data/VERSION

@@ -1 +1 @@
-0.14.6
+0.16.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/exe/ruby-lsp-doctor

@@ -4,6 +4,15 @@
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
+if File.exist?(".index.yml")
+  begin
+    config = YAML.parse_file(".index.yml").to_ruby
+  rescue => e
+    abort("Error parsing config: #{e.message}")
+  end
+  RubyIndexer.configuration.apply_config(config)
+end
+
 index = RubyIndexer::Index.new
 
 puts "Globbing for indexable files"

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

@@ -154,6 +154,8 @@ module RubyIndexer
         handle_attribute(node, reader: true, writer: true)
       when :include
         handle_include(node)
+      when :prepend
+        handle_prepend(node)
       end
     end
 
@@ -355,6 +357,16 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_include(node)
+      handle_module_operation(node, :included_modules)
+    end
+
+    sig { params(node: Prism::CallNode).void }
+    def handle_prepend(node)
+      handle_module_operation(node, :prepended_modules)
+    end
+
+    sig { params(node: Prism::CallNode, operation: Symbol).void }
+    def handle_module_operation(node, operation)
       return unless @current_owner
 
       arguments = node.arguments&.arguments
@@ -369,7 +381,8 @@ module RubyIndexer
         # If a constant path reference is dynamic or missing parts, we can't
         # index it
       end
-      @current_owner.included_modules.concat(names)
+      collection = operation == :included_modules ? @current_owner.included_modules : @current_owner.prepended_modules
+      collection.concat(names)
     end
   end
 end

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

@@ -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

@@ -43,6 +43,9 @@ module RubyIndexer
       sig { returns(T::Array[String]) }
       attr_accessor :included_modules
 
+      sig { returns(T::Array[String]) }
+      attr_accessor :prepended_modules
+
       sig do
         params(
           name: String,
@@ -54,6 +57,7 @@ module RubyIndexer
       def initialize(name, file_path, location, comments)
         super(name, file_path, location, comments)
         @included_modules = T.let([], T::Array[String])
+        @prepended_modules = T.let([], T::Array[String])
       end
 
       sig { returns(String) }

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -327,5 +327,51 @@ module RubyIndexer
       constant_path_references = T.must(@index["ConstantPathReferences"][0])
       assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.included_modules)
     end
+
+    def test_keeping_track_of_prepended_modules
+      index(<<~RUBY)
+        class Foo
+          # valid syntaxes that we can index
+          prepend A1
+          self.prepend A2
+          prepend A3, A4
+          self.prepend A5, A6
+
+          # valid syntaxes that we cannot index because of their dynamic nature
+          prepend some_variable_or_method_call
+          self.prepend some_variable_or_method_call
+
+          def something
+            prepend A7 # We should not index this because of this dynamic nature
+          end
+
+          # Valid inner class syntax definition with its own modules prepended
+          class Qux
+            prepend Corge
+            self.prepend Corge
+            prepend Baz
+
+            prepend some_variable_or_method_call
+          end
+        end
+
+        class ConstantPathReferences
+          prepend Foo::Bar
+          self.prepend Foo::Bar2
+
+          prepend dynamic::Bar
+          prepend Foo::
+        end
+      RUBY
+
+      foo = T.must(@index["Foo"][0])
+      assert_equal(["A1", "A2", "A3", "A4", "A5", "A6"], foo.prepended_modules)
+
+      qux = T.must(@index["Foo::Qux"][0])
+      assert_equal(["Corge", "Corge", "Baz"], qux.prepended_modules)
+
+      constant_path_references = T.must(@index["ConstantPathReferences"][0])
+      assert_equal(["Foo::Bar", "Foo::Bar2"], constant_path_references.prepended_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_lsp/addon.rb

@@ -50,8 +50,8 @@ module RubyLsp
       end
 
       # Discovers and loads all addons. Returns the list of activated addons
-      sig { params(message_queue: Thread::Queue).returns(T::Array[Addon]) }
-      def load_addons(message_queue)
+      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).returns(T::Array[Addon]) }
+      def load_addons(global_state, outgoing_queue)
         # Require all addons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
         Gem.find_files("ruby_lsp/**/addon.rb").each do |addon|
@@ -67,7 +67,7 @@ module RubyLsp
         # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server
         addons.each do |addon|
-          addon.activate(message_queue)
+          addon.activate(global_state, outgoing_queue)
         rescue => e
           addon.add_error(e)
         end
@@ -105,8 +105,8 @@ module RubyLsp
 
     # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.params(message_queue: Thread::Queue).void }
-    def activate(message_queue); end
+    sig { abstract.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+    def activate(global_state, outgoing_queue); end
 
     # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
@@ -132,11 +132,10 @@ module RubyLsp
       overridable.params(
         response_builder: ResponseBuilders::Hover,
         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, nesting, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
@@ -161,10 +160,20 @@ module RubyLsp
         response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
         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, 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],
+        nesting: T::Array[String],
+        dispatcher: Prism::Dispatcher,
+        uri: URI::Generic,
+      ).void
+    end
+    def create_completion_listener(response_builder, 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,52 @@
 # 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)
+      @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
+    end
+
+    sig { params(identifier: String, instance: Requests::Support::Formatter).void }
+    def register_formatter(identifier, instance)
+      @supported_formatters[identifier] = instance
+    end
+
+    sig { returns(T.nilable(Requests::Support::Formatter)) }
+    def active_formatter
+      @supported_formatters[@formatter]
+    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 +88,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"
@@ -33,3 +34,5 @@ require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
+require "ruby_lsp/requests/support/rubocop_formatter"
+require "ruby_lsp/requests/support/syntax_tree_formatter"