ruby-lsp 0.17.11 → 0.17.13

data/lib/ruby_lsp/global_state.rb

@@ -57,21 +57,48 @@ module RubyLsp
       @linters.filter_map { |name| @supported_formatters[name] }
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).void }
+    # Applies the options provided by the editor and returns an array of notifications to send back to the client
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Array[Notification]) }
     def apply_options(options)
+      notifications = []
       direct_dependencies = gather_direct_dependencies
       all_dependencies = gather_direct_and_indirect_dependencies
       workspace_uri = options.dig(:workspaceFolders, 0, :uri)
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
-      @formatter = specified_formatter if specified_formatter
-      @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
+
+      if specified_formatter
+        @formatter = specified_formatter
+
+        if specified_formatter != "auto"
+          notifications << Notification.window_log_message("Using formatter specified by user: #{@formatter}")
+        end
+      end
+
+      if @formatter == "auto"
+        @formatter = detect_formatter(direct_dependencies, all_dependencies)
+        notifications << Notification.window_log_message("Auto detected formatter: #{@formatter}")
+      end
 
       specified_linters = options.dig(:initializationOptions, :linters)
       @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
+
+      notifications << if specified_linters
+        Notification.window_log_message("Using linters specified by user: #{@linters.join(", ")}")
+      else
+        Notification.window_log_message("Auto detected linters: #{@linters.join(", ")}")
+      end
+
       @test_library = detect_test_library(direct_dependencies)
+      notifications << Notification.window_log_message("Detected test library: #{@test_library}")
+
       @has_type_checker = detect_typechecker(direct_dependencies)
+      if @has_type_checker
+        notifications << Notification.window_log_message(
+          "Ruby LSP detected this is a Sorbet project and will defer to the Sorbet LSP for some functionality",
+        )
+      end
 
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @encoding = if !encodings || encodings.empty?
@@ -91,6 +118,8 @@ module RubyLsp
 
       @experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
       @type_inferrer.experimental_features = @experimental_features
+
+      notifications
     end
 
     sig { returns(String) }
@@ -163,16 +192,7 @@ module RubyLsp
     def detect_typechecker(dependencies)
       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
-        sorbet_static_detected = dependencies.any?(/^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
+      dependencies.any?(/^sorbet-static/)
     rescue Bundler::GemfileNotFound
       false
     end

data/lib/ruby_lsp/listeners/completion.rb

@@ -56,7 +56,7 @@ module RubyLsp
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
           global_state: GlobalState,
           node_context: NodeContext,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
           trigger_character: T.nilable(String),
@@ -99,7 +99,7 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -122,7 +122,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -134,7 +134,7 @@ module RubyLsp
       def on_call_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        if @sorbet_level == Document::SorbetLevel::Ignore
+        if @sorbet_level == RubyDocument::SorbetLevel::Ignore
           receiver = node.receiver
 
           # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke
@@ -257,7 +257,7 @@ module RubyLsp
       def handle_instance_variable_completion(name, location)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
-        return if @sorbet_level == Document::SorbetLevel::Strict
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type

data/lib/ruby_lsp/listeners/definition.rb

@@ -20,7 +20,7 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
@@ -181,7 +181,7 @@ module RubyLsp
       def handle_instance_variable_definition(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
-        return if @sorbet_level == Document::SorbetLevel::Strict
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -289,7 +289,7 @@ module RubyLsp
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
           file_path = entry.file_path
-          next if @sorbet_level != Document::SorbetLevel::Ignore && not_in_dependencies?(file_path)
+          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(file_path)
 
           @response_builder << Interface::LocationLink.new(
             target_uri: URI::Generic.from_path(path: file_path).to_s,

data/lib/ruby_lsp/listeners/hover.rb

@@ -42,7 +42,7 @@ module RubyLsp
           uri: URI::Generic,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
@@ -73,7 +73,7 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -83,14 +83,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if @sorbet_level != Document::SorbetLevel::Ignore
+        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
 
         name = constant_name(node)
         return if name.nil?
@@ -174,7 +174,10 @@ module RubyLsp
         methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
         return unless methods
 
-        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+        first_method = T.must(methods.first)
+
+        title = "#{message}#{first_method.decorated_parameters}"
+        title << first_method.formatted_signatures
 
         if type.is_a?(TypeInferrer::GuessedType)
           title << "\n\nGuessed receiver: #{type.name}"
@@ -190,7 +193,7 @@ module RubyLsp
       def handle_instance_variable_hover(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
-        return if @sorbet_level == Document::SorbetLevel::Strict
+        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -13,7 +13,7 @@ module RubyLsp
           global_state: GlobalState,
           node_context: NodeContext,
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -23,6 +23,8 @@ module RubyLsp
     #
     class CodeActionResolve < Request
       extend T::Sig
+      include Support::Common
+
       NEW_VARIABLE_NAME = "new_variable"
       NEW_METHOD_NAME = "new_method"
 
@@ -36,7 +38,7 @@ module RubyLsp
         end
       end
 
-      sig { params(document: Document, code_action: T::Hash[Symbol, T.untyped]).void }
+      sig { params(document: RubyDocument, code_action: T::Hash[Symbol, T.untyped]).void }
       def initialize(document, code_action)
         super()
         @document = document
@@ -45,20 +47,62 @@ module RubyLsp
 
       sig { override.returns(T.any(Interface::CodeAction, Error)) }
       def perform
+        return Error::EmptySelection if @document.source.empty?
+
         case @code_action[:title]
         when CodeActions::EXTRACT_TO_VARIABLE_TITLE
           refactor_variable
         when CodeActions::EXTRACT_TO_METHOD_TITLE
           refactor_method
+        when CodeActions::TOGGLE_BLOCK_STYLE_TITLE
+          switch_block_style
         else
           Error::UnknownCodeAction
         end
       end
 
+      private
+
       sig { returns(T.any(Interface::CodeAction, Error)) }
-      def refactor_variable
-        return Error::EmptySelection if @document.source.empty?
+      def switch_block_style
+        source_range = @code_action.dig(:data, :range)
+        return Error::EmptySelection if source_range[:start] == source_range[:end]
+
+        target = @document.locate_first_within_range(
+          @code_action.dig(:data, :range),
+          node_types: [Prism::CallNode],
+        )
+
+        return Error::InvalidTargetRange unless target.is_a?(Prism::CallNode)
+
+        node = target.block
+        return Error::InvalidTargetRange unless node.is_a?(Prism::BlockNode)
 
+        indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
+
+        Interface::CodeAction.new(
+          title: CodeActions::TOGGLE_BLOCK_STYLE_TITLE,
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: [
+                  Interface::TextEdit.new(
+                    range: range_from_location(node.location),
+                    new_text: recursively_switch_nested_block_styles(node, indentation),
+                  ),
+                ],
+              ),
+            ],
+          ),
+        )
+      end
+
+      sig { returns(T.any(Interface::CodeAction, Error)) }
+      def refactor_variable
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
@@ -153,8 +197,6 @@ module RubyLsp
 
       sig { returns(T.any(Interface::CodeAction, Error)) }
       def refactor_method
-        return Error::EmptySelection if @document.source.empty?
-
         source_range = @code_action.dig(:data, :range)
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
@@ -206,8 +248,6 @@ module RubyLsp
         )
       end
 
-      private
-
       sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }
       def create_text_edit(range, new_text)
         Interface::TextEdit.new(
@@ -218,6 +258,64 @@ module RubyLsp
           new_text: new_text,
         )
       end
+
+      sig { params(node: Prism::BlockNode, indentation: T.nilable(String)).returns(String) }
+      def recursively_switch_nested_block_styles(node, indentation)
+        parameters = node.parameters
+        body = node.body
+
+        # We use the indentation to differentiate between do...end and brace style blocks because only the do...end
+        # style requires the indentation to build the edit.
+        #
+        # If the block is using `do...end` style, we change it to a single line brace block. Newlines are turned into
+        # semi colons, so that the result is valid Ruby code and still a one liner. If the block is using brace style,
+        # we do the opposite and turn it into a `do...end` block, making all semi colons into newlines.
+        source = +""
+
+        if indentation
+          source << "do"
+          source << " #{parameters.slice}" if parameters
+          source << "\n#{indentation}  "
+          source << switch_block_body(body, indentation) if body
+          source << "\n#{indentation}end"
+        else
+          source << "{ "
+          source << "#{parameters.slice} " if parameters
+          source << switch_block_body(body, nil) if body
+          source << "}"
+        end
+
+        source
+      end
+
+      sig { params(body: Prism::Node, indentation: T.nilable(String)).returns(String) }
+      def switch_block_body(body, indentation)
+        # Check if there are any nested blocks inside of the current block
+        body_loc = body.location
+        nested_block = @document.locate_first_within_range(
+          {
+            start: { line: body_loc.start_line - 1, character: body_loc.start_column },
+            end: { line: body_loc.end_line - 1, character: body_loc.end_column },
+          },
+          node_types: [Prism::BlockNode],
+        )
+
+        body_content = body.slice.dup
+
+        # If there are nested blocks, then we change their style too and we have to mutate the string using the
+        # relative position in respect to the beginning of the body
+        if nested_block.is_a?(Prism::BlockNode)
+          location = nested_block.location
+          correction_start = location.start_offset - body_loc.start_offset
+          correction_end = location.end_offset - body_loc.start_offset
+          next_indentation = indentation ? "#{indentation}  " : nil
+
+          body_content[correction_start...correction_end] =
+            recursively_switch_nested_block_styles(nested_block, next_indentation)
+        end
+
+        indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -21,6 +21,7 @@ module RubyLsp
 
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
+      TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
 
       class << self
         extend T::Sig
@@ -69,6 +70,11 @@ module RubyLsp
             kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
             data: { range: @range, uri: @uri.to_s },
           )
+          code_actions << Interface::CodeAction.new(
+            title: TOGGLE_BLOCK_STYLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_REWRITE,
+            data: { range: @range, uri: @uri.to_s },
+          )
         end
 
         code_actions

data/lib/ruby_lsp/requests/completion.rb

@@ -49,7 +49,7 @@ module RubyLsp
           document: Document,
           global_state: GlobalState,
           params: T::Hash[Symbol, T.untyped],
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
           dispatcher: Prism::Dispatcher,
         ).void
       end

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -63,6 +63,7 @@ module RubyLsp
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
           label = +"#{label}#{first_entry.decorated_parameters}"
+          label << first_entry.formatted_signatures
         end
 
         guessed_type = @item.dig(:data, :guessed_type)

data/lib/ruby_lsp/requests/definition.rb

@@ -42,7 +42,7 @@ module RubyLsp
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(document, global_state, position, dispatcher, sorbet_level)

data/lib/ruby_lsp/requests/hover.rb

@@ -36,7 +36,7 @@ module RubyLsp
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(document, global_state, position, dispatcher, sorbet_level)

data/lib/ruby_lsp/requests/signature_help.rb

@@ -46,7 +46,7 @@ module RubyLsp
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
-          sorbet_level: Document::SorbetLevel,
+          sorbet_level: RubyDocument::SorbetLevel,
         ).void
       end
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists

data/lib/ruby_lsp/requests/support/common.rb

@@ -209,9 +209,9 @@ module RubyLsp
           end
         end
 
-        sig { params(sorbet_level: Document::SorbetLevel).returns(T::Boolean) }
+        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
         def sorbet_level_true_or_higher?(sorbet_level)
-          sorbet_level == Document::SorbetLevel::True || sorbet_level == Document::SorbetLevel::Strict
+          sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
         end
       end
     end

data/lib/ruby_lsp/ruby_document.rb

@@ -3,6 +3,16 @@
 
 module RubyLsp
   class RubyDocument < Document
+    class SorbetLevel < T::Enum
+      enums do
+        None = new("none")
+        Ignore = new("ignore")
+        False = new("false")
+        True = new("true")
+        Strict = new("strict")
+      end
+    end
+
     sig { override.returns(Prism::ParseResult) }
     def parse
       return @parse_result unless @needs_parsing
@@ -20,5 +30,59 @@ module RubyLsp
     def language_id
       LanguageId::Ruby
     end
+
+    sig { returns(SorbetLevel) }
+    def sorbet_level
+      sigil = parse_result.magic_comments.find do |comment|
+        comment.key == "typed"
+      end&.value
+
+      case sigil
+      when "ignore"
+        SorbetLevel::Ignore
+      when "false"
+        SorbetLevel::False
+      when "true"
+        SorbetLevel::True
+      when "strict", "strong"
+        SorbetLevel::Strict
+      else
+        SorbetLevel::None
+      end
+    end
+
+    sig do
+      params(
+        range: T::Hash[Symbol, T.untyped],
+        node_types: T::Array[T.class_of(Prism::Node)],
+      ).returns(T.nilable(Prism::Node))
+    end
+    def locate_first_within_range(range, node_types: [])
+      scanner = create_scanner
+      start_position = scanner.find_char_position(range[:start])
+      end_position = scanner.find_char_position(range[:end])
+      desired_range = (start_position...end_position)
+      queue = T.let(@parse_result.value.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
+
+      until queue.empty?
+        candidate = queue.shift
+
+        # Skip nil child nodes
+        next if candidate.nil?
+
+        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
+        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
+        # sibling
+        T.unsafe(queue).unshift(*candidate.child_nodes)
+
+        # Skip if the current node doesn't cover the desired position
+        loc = candidate.location
+
+        if desired_range.cover?(loc.start_offset...loc.end_offset) &&
+            (node_types.empty? || node_types.any? { |type| candidate.class == type })
+          return candidate
+        end
+      end
+    end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -19,10 +19,10 @@ module RubyLsp
     def process_message(message)
       case message[:method]
       when "initialize"
-        $stderr.puts("Initializing Ruby LSP v#{VERSION}...")
+        send_log_message("Initializing Ruby LSP v#{VERSION}...")
         run_initialize(message)
       when "initialized"
-        $stderr.puts("Finished initializing Ruby LSP!") unless @test_mode
+        send_log_message("Finished initializing Ruby LSP!") unless @test_mode
         run_initialized
       when "textDocument/didOpen"
         text_document_did_open(message)
@@ -121,12 +121,20 @@ module RubyLsp
         end
       end
 
-      $stderr.puts("Error processing #{message[:method]}: #{e.full_message}")
+      send_log_message("Error processing #{message[:method]}: #{e.full_message}", type: Constant::MessageType::ERROR)
     end
 
     sig { void }
     def load_addons
-      Addon.load_addons(@global_state, @outgoing_queue)
+      errors = Addon.load_addons(@global_state, @outgoing_queue)
+
+      if errors.any?
+        send_log_message(
+          "Error loading addons:\n\n#{errors.map(&:full_message).join("\n\n")}",
+          type: Constant::MessageType::WARNING,
+        )
+      end
+
       errored_addons = Addon.addons.select(&:error?)
 
       if errored_addons.any?
@@ -140,7 +148,12 @@ module RubyLsp
           ),
         )
 
-        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n")) unless @test_mode
+        unless @test_mode
+          send_log_message(
+            errored_addons.map(&:errors_details).join("\n\n"),
+            type: Constant::MessageType::WARNING,
+          )
+        end
       end
     end
 
@@ -149,7 +162,7 @@ module RubyLsp
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def run_initialize(message)
       options = message[:params]
-      @global_state.apply_options(options)
+      global_state_notifications = @global_state.apply_options(options)
 
       client_name = options.dig(:clientInfo, :name)
       @store.client_name = client_name if client_name
@@ -258,6 +271,8 @@ module RubyLsp
       process_indexing_configuration(options.dig(:initializationOptions, :indexing))
 
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
+
+      global_state_notifications.each { |notification| send_message(notification) }
     end
 
     sig { void }
@@ -281,7 +296,7 @@ module RubyLsp
       @mutex.synchronize do
         text_document = message.dig(:params, :textDocument)
         language_id = case text_document[:languageId]
-        when "erb"
+        when "erb", "eruby"
           Document::LanguageId::ERB
         else
           Document::LanguageId::Ruby
@@ -480,9 +495,10 @@ module RubyLsp
       )
     end
 
-    sig { params(document: Document).returns(Document::SorbetLevel) }
+    sig { params(document: Document).returns(RubyDocument::SorbetLevel) }
     def sorbet_level(document)
-      return Document::SorbetLevel::Ignore unless @global_state.has_type_checker
+      return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
+      return RubyDocument::SorbetLevel::Ignore unless document.is_a?(RubyDocument)
 
       document.sorbet_level
     end
@@ -520,6 +536,12 @@ module RubyLsp
       params = message[:params]
       uri = URI(params.dig(:data, :uri))
       document = @store.get(uri)
+
+      unless document.is_a?(RubyDocument)
+        send_message(Notification.window_show_error("Code actions are currently only available for Ruby documents"))
+        raise Requests::CodeActionResolve::CodeActionError
+      end
+
       result = Requests::CodeActionResolve.new(document, params).perform
 
       case result
@@ -862,7 +884,7 @@ module RubyLsp
 
       if File.exist?(index_path)
         begin
-          RubyIndexer.configuration.apply_config(YAML.parse_file(index_path).to_ruby)
+          @global_state.index.configuration.apply_config(YAML.parse_file(index_path).to_ruby)
           send_message(
             Notification.new(
               method: "window/showMessage",
@@ -891,7 +913,7 @@ module RubyLsp
       return unless indexing_options
 
       # The index expects snake case configurations, but VS Code standardizes on camel case settings
-      RubyIndexer.configuration.apply_config(
+      @global_state.index.configuration.apply_config(
         indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase },
       )
     end