ruby-lsp 0.23.15 → 0.23.17

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -13,14 +13,9 @@ module RubyLsp
       NEW_METHOD_NAME = "new_method"
 
       class CodeActionError < StandardError; end
-
-      class Error < ::T::Enum
-        enums do
-          EmptySelection = new
-          InvalidTargetRange = new
-          UnknownCodeAction = new
-        end
-      end
+      class EmptySelectionError < CodeActionError; end
+      class InvalidTargetRangeError < CodeActionError; end
+      class UnknownCodeActionError < CodeActionError; end
 
       #: (RubyDocument document, GlobalState global_state, Hash[Symbol, untyped] code_action) -> void
       def initialize(document, global_state, code_action)
@@ -31,9 +26,9 @@ module RubyLsp
       end
 
       # @override
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def perform
-        return Error::EmptySelection if @document.source.empty?
+        raise EmptySelectionError, "Invalid selection for refactor" if @document.source.empty?
 
         case @code_action[:title]
         when CodeActions::EXTRACT_TO_VARIABLE_TITLE
@@ -47,26 +42,30 @@ module RubyLsp
              CodeActions::CREATE_ATTRIBUTE_ACCESSOR
           create_attribute_accessor
         else
-          Error::UnknownCodeAction
+          raise UnknownCodeActionError, "Unknown code action: #{@code_action[:title]}"
         end
       end
 
       private
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def switch_block_style
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" 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)
+        unless target.is_a?(Prism::CallNode)
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         node = target.block
-        return Error::InvalidTargetRange unless node.is_a?(Prism::BlockNode)
+        unless node.is_a?(Prism::BlockNode)
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         indentation = " " * target.location.start_column unless node.opening_loc.slice == "do"
 
@@ -91,10 +90,10 @@ module RubyLsp
         )
       end
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def refactor_variable
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = @document.source[start_index...end_index] #: as !nil
@@ -111,16 +110,20 @@ module RubyLsp
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
-        return Error::InvalidTargetRange if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
+        if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
         # immediately after that closest node
-        closest_node = T.must(closest_statements.child_nodes.compact.min_by do |node|
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
           distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
           distance <= 0 ? Float::INFINITY : distance
-        end)
+        end #: as !nil
 
-        return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
+        if closest_node.is_a?(Prism::MissingNode)
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         closest_node_loc = closest_node.location
         # If the parent expression is a single line block, then we have to extract it inside of the one-line block
@@ -151,7 +154,9 @@ module RubyLsp
           lines = @document.source.lines
 
           indentation_line = lines[indentation_line_number]
-          return Error::InvalidTargetRange unless indentation_line
+          unless indentation_line
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           indentation = indentation_line[/\A */] #: as !nil
             .size
@@ -162,7 +167,9 @@ module RubyLsp
           }
 
           line = lines[target_line]
-          return Error::InvalidTargetRange unless line
+          unless line
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           variable_source = if line.strip.empty?
             "\n#{" " * indentation}#{NEW_VARIABLE_NAME} = #{extracted_source}"
@@ -190,10 +197,10 @@ module RubyLsp
         )
       end
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def refactor_method
         source_range = @code_action.dig(:data, :range)
-        return Error::EmptySelection if source_range[:start] == source_range[:end]
+        raise EmptySelectionError, "Invalid selection for refactor" if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
         extracted_source = @document.source[start_index...end_index] #: as !nil
@@ -206,11 +213,15 @@ module RubyLsp
           code_units_cache: @document.code_units_cache,
         )
         closest_node = node_context.node
-        return Error::InvalidTargetRange unless closest_node
+        unless closest_node
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         target_range = if closest_node.is_a?(Prism::DefNode)
           end_keyword_loc = closest_node.end_keyword_loc
-          return Error::InvalidTargetRange unless end_keyword_loc
+          unless end_keyword_loc
+            raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+          end
 
           end_line = end_keyword_loc.end_line - 1
           character = end_keyword_loc.end_column
@@ -331,7 +342,7 @@ module RubyLsp
         indentation ? body_content.gsub(";", "\n") : "#{body_content.gsub("\n", ";")} "
       end
 
-      #: -> (Interface::CodeAction | Error)
+      #: -> (Interface::CodeAction)
       def create_attribute_accessor
         source_range = @code_action.dig(:data, :range)
 
@@ -349,20 +360,12 @@ module RubyLsp
           )
           node = node_context.node
 
-          return Error::EmptySelection unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+          unless CodeActions::INSTANCE_VARIABLE_NODES.include?(node.class)
+            raise EmptySelectionError, "Invalid selection for refactor"
+          end
         end
 
-        node = T.cast(
-          node,
-          T.any(
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-          ),
-        )
+        node = node #: as Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode # rubocop:disable Layout/LineLength
 
         node_context = @document.locate_node(
           {
@@ -376,20 +379,20 @@ module RubyLsp
           ],
         )
         closest_node = node_context.node
-        return Error::InvalidTargetRange if closest_node.nil?
+        if closest_node.nil?
+          raise InvalidTargetRangeError, "Couldn't find an appropriate location to place extracted refactor"
+        end
 
         attribute_name = node.name[1..]
         indentation = " " * (closest_node.location.start_column + 2)
-        attribute_accessor_source = T.must(
-          case @code_action[:title]
-          when CodeActions::CREATE_ATTRIBUTE_READER
-            "#{indentation}attr_reader :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_WRITER
-            "#{indentation}attr_writer :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
-            "#{indentation}attr_accessor :#{attribute_name}\n\n"
-          end,
-        )
+        attribute_accessor_source = case @code_action[:title]
+        when CodeActions::CREATE_ATTRIBUTE_READER
+          "#{indentation}attr_reader :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_WRITER
+          "#{indentation}attr_writer :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+          "#{indentation}attr_accessor :#{attribute_name}\n\n"
+        end #: as !nil
 
         target_start_line = closest_node.location.start_line
         target_range = {

data/lib/ruby_lsp/requests/code_lens.rb

@@ -20,20 +20,32 @@ module RubyLsp
 
       #: (GlobalState global_state, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(global_state, uri, dispatcher)
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens]
         super()
-        Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
+
+        @test_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
+
+        if global_state.enabled_feature?(:fullTestDiscovery)
+          Listeners::TestStyle.new(@test_builder, global_state, dispatcher, uri)
+          Listeners::SpecStyle.new(@test_builder, global_state, dispatcher, uri)
+        else
+          Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
+        end
 
         Addon.addons.each do |addon|
           addon.create_code_lens_listener(@response_builder, uri, dispatcher)
+
+          if global_state.enabled_feature?(:fullTestDiscovery)
+            addon.create_discover_tests_listener(@test_builder, dispatcher, uri)
+          end
         end
       end
 
       # @override
       #: -> Array[Interface::CodeLens]
       def perform
-        @response_builder.response
+        @response_builder.response + @test_builder.code_lens
       end
     end
   end

data/lib/ruby_lsp/requests/completion.rb

@@ -21,7 +21,7 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] params, RubyDocument::SorbetLevel sorbet_level, Prism::Dispatcher dispatcher) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] params, SorbetLevel sorbet_level, Prism::Dispatcher dispatcher) -> void
       def initialize(document, global_state, params, sorbet_level, dispatcher)
         super()
         @target = nil #: Prism::Node?
@@ -60,7 +60,7 @@ module RubyLsp
           ],
           code_units_cache: document.code_units_cache,
         )
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem]
 
         Listeners::Completion.new(

data/lib/ruby_lsp/requests/definition.rb

@@ -11,12 +11,11 @@ module RubyLsp
     class Definition < Request
       extend T::Generic
 
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[
-          T.any(Interface::Location, Interface::LocationLink)
-        ].new #: ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)]
         @dispatcher = dispatcher
 
         char_position, _ = document.find_index_by_position(position)

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -25,7 +25,7 @@ module RubyLsp
           code_units_cache: document.code_units_cache,
         )
 
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
         Listeners::DocumentHighlight.new(
           @response_builder,

data/lib/ruby_lsp/requests/document_link.rb

@@ -19,7 +19,7 @@ module RubyLsp
       #: (URI::Generic uri, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, comments, dispatcher)
         super()
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
         Listeners::DocumentLink.new(@response_builder, uri, comments, dispatcher)
       end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -18,7 +18,7 @@ module RubyLsp
       #: (Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(comments, dispatcher)
         super()
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
         @listener = Listeners::FoldingRanges.new(@response_builder, comments, dispatcher) #: Listeners::FoldingRanges
       end

data/lib/ruby_lsp/requests/go_to_relevant_file.rb

@@ -8,8 +8,6 @@ module RubyLsp
     # that navigates to the relevant file for the current document.
     # Currently, it supports source code file <> test file navigation.
     class GoToRelevantFile < Request
-      extend T::Sig
-
       TEST_KEYWORDS = ["test", "spec", "integration_test"]
 
       TEST_PREFIX_PATTERN = /^(#{TEST_KEYWORDS.join("_|")}_)/

data/lib/ruby_lsp/requests/hover.rb

@@ -19,7 +19,7 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
 
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -20,7 +20,7 @@ module RubyLsp
       def initialize(document, hints_configuration, dispatcher)
         super()
 
-        @response_builder = ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
           .new #: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
         Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
       end

data/lib/ruby_lsp/requests/references.rb

@@ -55,22 +55,7 @@ module RubyLsp
           )
         end
 
-        target = T.cast(
-          target,
-          T.any(
-            Prism::ConstantReadNode,
-            Prism::ConstantPathNode,
-            Prism::ConstantPathTargetNode,
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-            Prism::CallNode,
-            Prism::DefNode,
-          ),
-        )
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode, # rubocop:disable Layout/LineLength
 
         reference_target = create_reference_target(target, node_context)
         return @locations unless reference_target

data/lib/ruby_lsp/requests/rename.rb

@@ -51,10 +51,7 @@ module RubyLsp
           )
         end
 
-        target = T.cast(
-          target,
-          T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
-        )
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode
 
         name = RubyIndexer::Index.constant_name(target)
         return unless name

data/lib/ruby_lsp/requests/request.rb

@@ -60,7 +60,8 @@ module RubyLsp
         return target unless parent.is_a?(Prism::ConstantPathNode)
 
         target = parent #: Prism::Node
-        parent = T.cast(target, Prism::ConstantPathNode).parent #: Prism::Node?
+        parent = target #: as Prism::ConstantPathNode
+          .parent #: Prism::Node?
 
         while parent && cover?(parent.location, position)
           target = parent

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -32,7 +32,7 @@ module RubyLsp
           next unless node
 
           range = Support::SelectionRange.new(range: range_from_location(node.location), parent: parent)
-          T.unsafe(queue).unshift(*node.child_nodes.map { |child| [child, range] })
+          queue.unshift(*node.child_nodes.map { |child| [child, range] })
           @ranges.unshift(range)
         end
 

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -74,7 +74,7 @@ module RubyLsp
       @result_id = 0 #: Integer
       @mutex = Mutex.new #: Mutex
 
-      #: (GlobalState global_state, Prism::Dispatcher dispatcher, (RubyDocument | ERBDocument) document, String? previous_result_id, ?range: T::Range[Integer]?) -> void
+      #: (GlobalState global_state, Prism::Dispatcher dispatcher, (RubyDocument | ERBDocument) document, String? previous_result_id, ?range: Range[Integer]?) -> void
       def initialize(global_state, dispatcher, document, previous_result_id, range: nil)
         super()
 

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -46,7 +46,7 @@ module RubyLsp
           if (start_char..end_char).cover?(loc.start_offset..loc.end_offset)
             found_nodes << node
           else
-            T.unsafe(queue).unshift(*node.child_nodes)
+            queue.unshift(*node.child_nodes)
           end
         end
 

data/lib/ruby_lsp/requests/signature_help.rb

@@ -19,7 +19,7 @@ module RubyLsp
         end
       end
 
-      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Hash[Symbol, untyped]? context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Hash[Symbol, untyped]? context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 

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

@@ -5,7 +5,7 @@ module RubyLsp
   module Requests
     module Support
       class Annotation
-        #: (arity: (Integer | T::Range[Integer]), ?receiver: bool) -> void
+        #: (arity: (Integer | Range[Integer]), ?receiver: bool) -> void
         def initialize(arity:, receiver: false)
           @arity = arity
           @receiver = receiver

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

@@ -159,11 +159,6 @@ module RubyLsp
             Constant::SymbolKind::FIELD
           end
         end
-
-        #: (RubyDocument::SorbetLevel sorbet_level) -> bool
-        def sorbet_level_true_or_higher?(sorbet_level)
-          sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
-        end
       end
     end
   end

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

@@ -21,8 +21,10 @@ module URI
     # have the uri gem in their own bundle and thus not use a compatible version.
     PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
-    T.unsafe(self).alias_method(:gem_name, :host)
-    T.unsafe(self).alias_method(:line_number, :fragment)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:gem_name, :host)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:line_number, :fragment)
 
     #: String?
     attr_reader :gem_version

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

@@ -13,6 +13,12 @@ module RubyLsp
         #: String
         attr_reader :id, :label
 
+        #: URI::Generic
+        attr_reader :uri
+
+        #: Interface::Range
+        attr_reader :range
+
         #: (String id, String label, URI::Generic uri, Interface::Range range, Symbol framework) -> void
         def initialize(id, label, uri, range, framework:)
           @id = id

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -32,7 +32,7 @@ module RubyLsp
       #: -> Interface::DocumentSymbol?
       def pop
         if @stack.size > 1
-          T.cast(@stack.pop, Interface::DocumentSymbol)
+          @stack.pop #: as Interface::DocumentSymbol
         end
       end
 

data/lib/ruby_lsp/response_builders/test_collection.rb

@@ -8,10 +8,14 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: Requests::Support::TestItem } }
 
+      #: Array[Interface::CodeLens]
+      attr_reader :code_lens
+
       #: -> void
       def initialize
         super
         @items = {} #: Hash[String, ResponseType]
+        @code_lens = [] #: Array[Interface::CodeLens]
       end
 
       #: (ResponseType item) -> void
@@ -19,6 +23,39 @@ module RubyLsp
         @items[item.id] = item
       end
 
+      #: (ResponseType item) -> void
+      def add_code_lens(item)
+        range = item.range
+        arguments = [item.uri.to_standardized_path, item.id]
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          command: Interface::Command.new(
+            title: "▶ Run",
+            command: "rubyLsp.runTest",
+            arguments: arguments,
+          ),
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          command: Interface::Command.new(
+            title: "▶ Run In Terminal",
+            command: "rubyLsp.runTestInTerminal",
+            arguments: arguments,
+          ),
+        )
+
+        @code_lens << Interface::CodeLens.new(
+          range: range,
+          command: Interface::Command.new(
+            title: "⚙ Debug",
+            command: "rubyLsp.debugTest",
+            arguments: arguments,
+          ),
+        )
+      end
+
       #: (String id) -> ResponseType?
       def [](id)
         @items[id]

data/lib/ruby_lsp/ruby_document.rb

@@ -23,16 +23,6 @@ module RubyLsp
       :private_class_method,
     ].freeze
 
-    class SorbetLevel < T::Enum
-      enums do
-        None = new("none")
-        Ignore = new("ignore")
-        False = new("false")
-        True = new("true")
-        Strict = new("strict")
-      end
-    end
-
     class << self
       #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
@@ -53,7 +43,7 @@ module RubyLsp
           # 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)
+          queue.unshift(*candidate.child_nodes)
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
@@ -154,29 +144,9 @@ module RubyLsp
     end
 
     # @override
-    #: -> LanguageId
+    #: -> Symbol
     def language_id
-      LanguageId::Ruby
-    end
-
-    #: -> 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
+      :ruby
     end
 
     #: (Hash[Symbol, untyped] range, ?node_types: Array[singleton(Prism::Node)]) -> Prism::Node?
@@ -195,7 +165,7 @@ module RubyLsp
         # 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)
+        queue.unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location