ruby-lsp 0.13.1 → 0.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78df9c8d35fc18cea6fc06a0f679b48b69e3daaaf504d762d2f5ae4df9d99ad0
-  data.tar.gz: 3c251eed7939e81c5aa115d303b2876d3769c509ef0487b0faa26d1a2de79c50
+  metadata.gz: 28e657dce7a85c270d1c647a158fd1a1c5f81dca211844defd817070fd264126
+  data.tar.gz: f129245dd0e632916573c0b9dcf04bfaa2c7b942b39aaa6aa1618dd70f13e69e
 SHA512:
-  metadata.gz: af33b81309429318e7fe61dc4a2bd989328b8e9127097ab621eab162e61e1b2d93f1be1b192307d3b48f47659489343e093d92125e9c68895c40517803dba5ed
-  data.tar.gz: 6373eb77209eb865e29026fba603f4db8d3249949bcff7c0aee3f550569a7225c84b76d5872fd61a8798c0ef04da2d538b50b4d3045697ef40cc85336a2c715b
+  metadata.gz: 3ab4afce37f672fd0d3c3ecc54c7b30247f893fc4b7b4f10549e13db4ab181c67a9b84da37dea9fbdd195e8d87ca2f2f794cbcce300c68b4709ee0ae3b3171b2
+  data.tar.gz: ffdb3a1bdb2d5c4172f74c934da896bd6c19f09158effa137afd0443e79b8c2dfd392989997d5745616db58e1286191a9e35570bd69024779137e7aaf15bb987

data/README.md

@@ -46,6 +46,36 @@ See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth de
 For creating rich themes for Ruby using the semantic highlighting information, see the [semantic highlighting
 documentation](SEMANTIC_HIGHLIGHTING.md).
 
+### Configuring code indexing
+
+By default, the Ruby LSP indexes all Ruby files defined in the current project and all of its dependencies, including
+default gems, except for
+
+- Gems that only appear under the `:development` group
+- All Ruby files under `test/**/*.rb`
+
+By creating a `.index.yml` file, these configurations can be overridden and tuned.
+
+```yaml
+# Exclude files based on a given pattern. Often used to exclude test files or fixtures
+excluded_patterns:
+  - "**/spec/**/*.rb"
+
+# Include files based on a given pattern. Can be used to index Ruby files that use different extensions
+included_patterns:
+  - "**/bin/*"
+
+# Exclude gems by name. If a gem is never referenced in the project's code and is only used as a tool, excluding it will
+# speed up indexing and reduce the amount of results in features like definition or completion
+excluded_gems:
+  - rubocop
+  - pathname
+
+# Include gems by name. Normally used to include development gems that are excluded by default
+included_gems:
+  - prism
+```
+
 ### Addons
 
 The Ruby LSP provides an addon system that allows other gems to enhance the base functionality with more editor

data/VERSION

@@ -1 +1 @@
-0.13.1
+0.13.3

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

@@ -193,7 +193,7 @@ module RubyIndexer
       # When working on a gem, we need to make sure that its gemspec dependencies can't be excluded. This is necessary
       # because Bundler doesn't assign groups to gemspec dependencies
       this_gem = Bundler.definition.dependencies.find do |d|
-        d.to_spec.full_gem_path == Dir.pwd
+        d.to_spec&.full_gem_path == Dir.pwd
       rescue Gem::MissingSpecError
         false
       end

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

@@ -81,9 +81,13 @@ module RubyIndexer
 
       abstract!
 
+      # Name includes just the name of the parameter, excluding symbols like splats
       sig { returns(Symbol) }
       attr_reader :name
 
+      # Decorated name is the parameter name including the splat or block prefix, e.g.: `*foo`, `**foo` or `&block`
+      alias_method :decorated_name, :name
+
       sig { params(name: Symbol).void }
       def initialize(name:)
         @name = name
@@ -100,25 +104,48 @@ module RubyIndexer
 
     # An required keyword method parameter, e.g. `def foo(a:)`
     class KeywordParameter < Parameter
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"#{@name}:"
+      end
     end
 
     # An optional keyword method parameter, e.g. `def foo(a: 123)`
     class OptionalKeywordParameter < Parameter
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"#{@name}:"
+      end
     end
 
     # A rest method parameter, e.g. `def foo(*a)`
     class RestParameter < Parameter
       DEFAULT_NAME = T.let(:"<anonymous splat>", Symbol)
+
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"*#{@name}"
+      end
     end
 
     # A keyword rest method parameter, e.g. `def foo(**a)`
     class KeywordRestParameter < Parameter
       DEFAULT_NAME = T.let(:"<anonymous keyword splat>", Symbol)
+
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"**#{@name}"
+      end
     end
 
     # A block method parameter, e.g. `def foo(&block)`
     class BlockParameter < Parameter
       DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
+
+      sig { override.returns(Symbol) }
+      def decorated_name
+        :"&#{@name}"
+      end
     end
 
     class Member < Entry
@@ -220,7 +247,7 @@ module RubyIndexer
 
         rest = parameters_node.rest
 
-        if rest
+        if rest.is_a?(Prism::RestParameterNode)
           rest_name = rest.name || RestParameter::DEFAULT_NAME
           parameters << RestParameter.new(name: rest_name)
         end
@@ -261,6 +288,8 @@ module RubyIndexer
             names << (rest.operator == "*" ? "*#{name}".to_sym : name&.to_sym)
           end
 
+          names << nil if rest.is_a?(Prism::ImplicitRestNode)
+
           names.concat(node.rights.map { |parameter_node| parameter_name(parameter_node) })
 
           names_with_commas = names.join(", ")

data/lib/ruby_lsp/check_docs.rb

@@ -51,15 +51,15 @@ module RubyLsp
 
       # Find all classes that inherit from BaseRequest or Listener, which are the ones we want to make sure are
       # documented
-      features = ObjectSpace.each_object(Class).filter_map do |k|
+      features = ObjectSpace.each_object(Class).select do |k|
         klass = T.unsafe(k)
-        klass if klass < Requests::BaseRequest || (klass < Listener && klass != ExtensibleListener)
+        klass < Requests::Request
       end
 
       missing_docs = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
 
       features.each do |klass|
-        class_name = T.must(klass.name)
+        class_name = T.unsafe(klass).name
         file_path, line_number = Module.const_source_location(class_name)
         next unless file_path && line_number
 

data/lib/ruby_lsp/document.rb

@@ -8,10 +8,6 @@ module RubyLsp
 
     abstract!
 
-    PositionShape = T.type_alias { { line: Integer, character: Integer } }
-    RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
-    EditShape = T.type_alias { { range: RangeShape, text: String } }
-
     sig { returns(Prism::ParseResult) }
     attr_reader :parse_result
 
@@ -80,7 +76,7 @@ module RubyLsp
       @cache[request_name]
     end
 
-    sig { params(edits: T::Array[EditShape], version: Integer).void }
+    sig { params(edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
     def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
@@ -112,7 +108,7 @@ module RubyLsp
 
     sig do
       params(
-        position: PositionShape,
+        position: T::Hash[Symbol, T.untyped],
         node_types: T::Array[T.class_of(Prism::Node)],
       ).returns([T.nilable(Prism::Node), T.nilable(Prism::Node), T::Array[String]])
     end
@@ -177,6 +173,18 @@ module RubyLsp
       [closest, parent, nesting.map { |n| n.constant_path.location.slice }]
     end
 
+    sig { returns(T::Boolean) }
+    def sorbet_sigil_is_true_or_higher
+      parse_result.magic_comments.any? do |comment|
+        comment.key == "typed" && ["true", "strict", "strong"].include?(comment.value)
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def typechecker_enabled?
+      DependencyDetector.instance.typechecker && sorbet_sigil_is_true_or_higher
+    end
+
     class Scanner
       extend T::Sig
 
@@ -193,7 +201,7 @@ module RubyLsp
       end
 
       # Finds the character index inside the source string for a given line and column
-      sig { params(position: PositionShape).returns(Integer) }
+      sig { params(position: T::Hash[Symbol, T.untyped]).returns(Integer) }
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]

data/lib/ruby_lsp/executor.rb

@@ -25,6 +25,7 @@ module RubyLsp
       begin
         response = run(request)
       rescue StandardError, LoadError => e
+        warn(e.message)
         error = e
       end
 
@@ -93,7 +94,7 @@ module RubyLsp
         cached_response = document.cache_get(request[:method])
         return cached_response if cached_response
 
-        # Run listeners for the document
+        # Run requests for the document
         dispatcher = Prism::Dispatcher.new
         folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
         document_symbol = Requests::DocumentSymbol.new(dispatcher)
@@ -106,13 +107,13 @@ module RubyLsp
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
         # we actually received
-        document.cache_set("textDocument/foldingRange", folding_range.response)
-        document.cache_set("textDocument/documentSymbol", document_symbol.response)
-        document.cache_set("textDocument/documentLink", document_link.response)
-        document.cache_set("textDocument/codeLens", code_lens.response)
+        document.cache_set("textDocument/foldingRange", folding_range.perform)
+        document.cache_set("textDocument/documentSymbol", document_symbol.perform)
+        document.cache_set("textDocument/documentLink", document_link.perform)
+        document.cache_set("textDocument/codeLens", code_lens.perform)
         document.cache_set(
           "textDocument/semanticTokens/full",
-          Requests::Support::SemanticTokenEncoder.new.encode(semantic_highlighting.response),
+          Requests::Support::SemanticTokenEncoder.new.encode(semantic_highlighting.perform),
         )
         document.cache_get(request[:method])
       when "textDocument/semanticTokens/range"
@@ -142,13 +143,30 @@ module RubyLsp
           nil
         end
       when "textDocument/documentHighlight"
-        document_highlight(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        request = Requests::DocumentHighlight.new(document, request.dig(:params, :position), dispatcher)
+        dispatcher.dispatch(document.tree)
+        request.perform
       when "textDocument/onTypeFormatting"
         on_type_formatting(uri, request.dig(:params, :position), request.dig(:params, :ch))
       when "textDocument/hover"
-        hover(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        Requests::Hover.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          dispatcher,
+          document.typechecker_enabled?,
+        ).perform
       when "textDocument/inlayHint"
-        inlay_hint(uri, request.dig(:params, :range))
+        hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        request = Requests::InlayHints.new(document, request.dig(:params, :range), hints_configurations, dispatcher)
+        dispatcher.visit(document.tree)
+        request.perform
       when "textDocument/codeAction"
         code_action(uri, request.dig(:params, :range), request.dig(:params, :context))
       when "codeAction/resolve"
@@ -168,9 +186,36 @@ module RubyLsp
           nil
         end
       when "textDocument/completion"
-        completion(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        Requests::Completion.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          document.typechecker_enabled?,
+          dispatcher,
+        ).perform
+      when "textDocument/signatureHelp"
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+
+        Requests::SignatureHelp.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          request.dig(:params, :context),
+          dispatcher,
+        ).perform
       when "textDocument/definition"
-        definition(uri, request.dig(:params, :position))
+        dispatcher = Prism::Dispatcher.new
+        document = @store.get(uri)
+        Requests::Definition.new(
+          document,
+          @index,
+          request.dig(:params, :position),
+          dispatcher,
+          document.typechecker_enabled?,
+        ).perform
       when "workspace/didChangeWatchedFiles"
         did_change_watched_files(request.dig(:params, :changes))
       when "workspace/symbol"
@@ -242,66 +287,16 @@ module RubyLsp
 
     sig { params(query: T.nilable(String)).returns(T::Array[Interface::WorkspaceSymbol]) }
     def workspace_symbol(query)
-      Requests::WorkspaceSymbol.new(query, @index).run
+      Requests::WorkspaceSymbol.new(query, @index).perform
     end
 
-    sig { params(uri: URI::Generic, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
+    sig { params(uri: URI::Generic, range: T.nilable(T::Hash[Symbol, T.untyped])).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
-      { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: Document::PositionShape,
-      ).returns(T.nilable(T.any(T::Array[Interface::Location], Interface::Location)))
-    end
-    def definition(uri, position)
-      document = @store.get(uri)
-      target, parent, nesting = document.locate_node(
-        position,
-        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
-      )
-
-      target = parent if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
-
-      dispatcher = Prism::Dispatcher.new
-      base_listener = Requests::Definition.new(uri, nesting, @index, dispatcher)
-      dispatcher.dispatch_once(target)
-      base_listener.response
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: Document::PositionShape,
-      ).returns(T.nilable(Interface::Hover))
-    end
-    def hover(uri, position)
-      document = @store.get(uri)
-      target, parent, nesting = document.locate_node(
-        position,
-        node_types: Requests::Hover::ALLOWED_TARGETS,
-      )
-
-      if (Requests::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-          !Requests::Hover::ALLOWED_TARGETS.include?(target.class)) ||
-          (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
-        target = parent
-      end
-
-      # Instantiate all listeners
-      dispatcher = Prism::Dispatcher.new
-      hover = Requests::Hover.new(@index, nesting, dispatcher)
-
-      # Emit events for all listeners
-      dispatcher.dispatch_once(target)
-
-      hover.response
+      { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).perform }
     end
 
     sig do
-      params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object)
+      params(uri: URI::Generic, content_changes: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).returns(Object)
     end
     def text_document_did_change(uri, content_changes, version)
       @store.push_edits(uri: uri, edits: content_changes, version: version)
@@ -323,12 +318,12 @@ module RubyLsp
     sig do
       params(
         uri: URI::Generic,
-        positions: T::Array[Document::PositionShape],
+        positions: T::Array[T::Hash[Symbol, T.untyped]],
       ).returns(T.nilable(T::Array[T.nilable(Requests::Support::SelectionRange)]))
     end
     def selection_range(uri, positions)
       ranges = @store.cache_fetch(uri, "textDocument/selectionRange") do |document|
-        Requests::SelectionRanges.new(document).run
+        Requests::SelectionRanges.new(document).perform
       end
 
       # Per the selection range request spec (https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange),
@@ -355,68 +350,38 @@ module RubyLsp
       path = uri.to_standardized_path
       return unless path.nil? || path.start_with?(T.must(@store.workspace_uri.to_standardized_path))
 
-      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).run
+      Requests::Formatting.new(@store.get(uri), formatter: @store.formatter).perform
     end
 
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
+        position: T::Hash[Symbol, T.untyped],
         character: String,
       ).returns(T::Array[Interface::TextEdit])
     end
     def on_type_formatting(uri, position, character)
-      Requests::OnTypeFormatting.new(@store.get(uri), position, character).run
+      Requests::OnTypeFormatting.new(@store.get(uri), position, character).perform
     end
 
     sig do
       params(
         uri: URI::Generic,
-        position: Document::PositionShape,
-      ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
-    end
-    def document_highlight(uri, position)
-      document = @store.get(uri)
-
-      target, parent = document.locate_node(position)
-      dispatcher = Prism::Dispatcher.new
-      listener = Requests::DocumentHighlight.new(target, parent, dispatcher)
-      dispatcher.visit(document.tree)
-      listener.response
-    end
-
-    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
-    def inlay_hint(uri, range)
-      document = @store.get(uri)
-
-      start_line = range.dig(:start, :line)
-      end_line = range.dig(:end, :line)
-
-      dispatcher = Prism::Dispatcher.new
-      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
-      listener = Requests::InlayHints.new(start_line..end_line, hints_configurations, dispatcher)
-      dispatcher.visit(document.tree)
-      listener.response
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        range: Document::RangeShape,
+        range: T::Hash[Symbol, T.untyped],
         context: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T::Array[Interface::CodeAction]))
     end
     def code_action(uri, range, context)
       document = @store.get(uri)
 
-      Requests::CodeActions.new(document, range, context).run
+      Requests::CodeActions.new(document, range, context).perform
     end
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
     def code_action_resolve(params)
       uri = URI(params.dig(:data, :uri))
       document = @store.get(uri)
-      result = Requests::CodeActionResolve.new(document, params).run
+      result = Requests::CodeActionResolve.new(document, params).perform
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection
@@ -450,74 +415,23 @@ module RubyLsp
       return unless path.nil? || path.start_with?(T.must(@store.workspace_uri.to_standardized_path))
 
       response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
-        Requests::Diagnostics.new(document).run
+        Requests::Diagnostics.new(document).perform
       end
 
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response) if response
     end
 
-    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(Interface::SemanticTokens) }
+    sig { params(uri: URI::Generic, range: T::Hash[Symbol, T.untyped]).returns(Interface::SemanticTokens) }
     def semantic_tokens_range(uri, range)
       document = @store.get(uri)
       start_line = range.dig(:start, :line)
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
+      request = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
       dispatcher.visit(document.tree)
 
-      Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
-    end
-
-    sig do
-      params(
-        uri: URI::Generic,
-        position: Document::PositionShape,
-      ).returns(T.nilable(T::Array[Interface::CompletionItem]))
-    end
-    def completion(uri, position)
-      document = @store.get(uri)
-
-      # Completion always receives the position immediately after the character that was just typed. Here we adjust it
-      # back by 1, so that we find the right node
-      char_position = document.create_scanner.find_char_position(position) - 1
-      matched, parent, nesting = document.locate(
-        document.tree,
-        char_position,
-        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
-      )
-      return unless matched && parent
-
-      target = case matched
-      when Prism::CallNode
-        message = matched.message
-
-        if message == "require"
-          args = matched.arguments&.arguments
-          return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
-
-          argument = args.first
-          return unless argument.is_a?(Prism::StringNode)
-          return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
-
-          argument
-        else
-          matched
-        end
-      when Prism::ConstantReadNode, Prism::ConstantPathNode
-        if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
-          parent
-        else
-          matched
-        end
-      end
-
-      return unless target
-
-      dispatcher = Prism::Dispatcher.new
-      listener = Requests::Completion.new(@index, nesting, dispatcher)
-      dispatcher.dispatch_once(target)
-      listener.response
+      Requests::Support::SemanticTokenEncoder.new.encode(request.perform)
     end
 
     sig { params(id: String, title: String, percentage: Integer).void }
@@ -623,74 +537,18 @@ module RubyLsp
         Hash.new(true)
       end
 
-      document_symbol_provider = if enabled_features["documentSymbols"]
-        Interface::DocumentSymbolClientCapabilities.new(
-          hierarchical_document_symbol_support: true,
-          symbol_kind: {
-            value_set: (Constant::SymbolKind::FILE..Constant::SymbolKind::TYPE_PARAMETER).to_a,
-          },
-        )
-      end
-
-      document_link_provider = if enabled_features["documentLink"]
-        Interface::DocumentLinkOptions.new(resolve_provider: false)
-      end
-
-      code_lens_provider = if enabled_features["codeLens"]
-        Interface::CodeLensOptions.new(resolve_provider: false)
-      end
-
-      hover_provider = if enabled_features["hover"]
-        Interface::HoverClientCapabilities.new(dynamic_registration: false)
-      end
-
-      folding_ranges_provider = if enabled_features["foldingRanges"]
-        Interface::FoldingRangeClientCapabilities.new(line_folding_only: true)
-      end
-
-      semantic_tokens_provider = if enabled_features["semanticHighlighting"]
-        Interface::SemanticTokensRegistrationOptions.new(
-          document_selector: { scheme: "file", language: "ruby" },
-          legend: Interface::SemanticTokensLegend.new(
-            token_types: Requests::SemanticHighlighting::TOKEN_TYPES.keys,
-            token_modifiers: Requests::SemanticHighlighting::TOKEN_MODIFIERS.keys,
-          ),
-          range: true,
-          full: { delta: false },
-        )
-      end
-
-      diagnostics_provider = if enabled_features["diagnostics"]
-        {
-          interFileDependencies: false,
-          workspaceDiagnostics: false,
-        }
-      end
-
-      on_type_formatting_provider = if enabled_features["onTypeFormatting"]
-        Interface::DocumentOnTypeFormattingOptions.new(
-          first_trigger_character: "{",
-          more_trigger_character: ["\n", "|", "d"],
-        )
-      end
-
-      code_action_provider = if enabled_features["codeActions"]
-        Interface::CodeActionOptions.new(resolve_provider: true)
-      end
-
-      inlay_hint_provider = if enabled_features["inlayHint"]
-        Interface::InlayHintOptions.new(resolve_provider: false)
-      end
-
-      completion_provider = if enabled_features["completion"]
-        Interface::CompletionOptions.new(
-          resolve_provider: false,
-          trigger_characters: ["/"],
-          completion_item: {
-            labelDetailsSupport: true,
-          },
-        )
-      end
+      document_symbol_provider = Requests::DocumentSymbol.provider if enabled_features["documentSymbols"]
+      document_link_provider = Requests::DocumentLink.provider if enabled_features["documentLink"]
+      code_lens_provider = Requests::CodeLens.provider if enabled_features["codeLens"]
+      hover_provider = Requests::Hover.provider if enabled_features["hover"]
+      folding_ranges_provider = Requests::FoldingRanges.provider if enabled_features["foldingRanges"]
+      semantic_tokens_provider = Requests::SemanticHighlighting.provider if enabled_features["semanticHighlighting"]
+      diagnostics_provider = Requests::Diagnostics.provider if enabled_features["diagnostics"]
+      on_type_formatting_provider = Requests::OnTypeFormatting.provider if enabled_features["onTypeFormatting"]
+      code_action_provider = Requests::CodeActions.provider if enabled_features["codeActions"]
+      inlay_hint_provider = Requests::InlayHints.provider if enabled_features["inlayHint"]
+      completion_provider = Requests::Completion.provider if enabled_features["completion"]
+      signature_help_provider = Requests::SignatureHelp.provider if enabled_features["signatureHelp"]
 
       # Dynamically registered capabilities
       file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
@@ -744,6 +602,7 @@ module RubyLsp
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
           workspace_symbol_provider: enabled_features["workspaceSymbol"],
+          signature_help_provider: signature_help_provider,
         ),
         serverInfo: {
           name: "Ruby LSP",