ruby-lsp 0.12.5 → 0.13.1

data/lib/ruby_lsp/executor.rb

@@ -41,7 +41,7 @@ module RubyLsp
       when "initialize"
         initialize_request(request.dig(:params))
       when "initialized"
-        Addon.load_addons
+        Addon.load_addons(@message_queue)
 
         errored_addons = Addon.addons.select(&:error?)
 
@@ -95,12 +95,13 @@ module RubyLsp
 
         # Run listeners for the document
         dispatcher = Prism::Dispatcher.new
-        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher, @message_queue)
-        document_symbol = Requests::DocumentSymbol.new(dispatcher, @message_queue)
-        document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher, @message_queue)
-        code_lens = Requests::CodeLens.new(uri, dispatcher, @message_queue)
+        folding_range = Requests::FoldingRanges.new(document.parse_result.comments, dispatcher)
+        document_symbol = Requests::DocumentSymbol.new(dispatcher)
+        document_link = Requests::DocumentLink.new(uri, document.comments, dispatcher)
+        lenses_configuration = T.must(@store.features_configuration.dig(:codeLens))
+        code_lens = Requests::CodeLens.new(uri, lenses_configuration, dispatcher)
 
-        semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher, @message_queue)
+        semantic_highlighting = Requests::SemanticHighlighting.new(dispatcher)
         dispatcher.dispatch(document.tree)
 
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
@@ -265,13 +266,7 @@ module RubyLsp
       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,
-        @message_queue,
-      )
+      base_listener = Requests::Definition.new(uri, nesting, @index, dispatcher)
       dispatcher.dispatch_once(target)
       base_listener.response
     end
@@ -297,7 +292,7 @@ module RubyLsp
 
       # Instantiate all listeners
       dispatcher = Prism::Dispatcher.new
-      hover = Requests::Hover.new(@index, nesting, dispatcher, @message_queue)
+      hover = Requests::Hover.new(@index, nesting, dispatcher)
 
       # Emit events for all listeners
       dispatcher.dispatch_once(target)
@@ -355,6 +350,11 @@ module RubyLsp
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       return if @store.formatter == "none"
 
+      # Do not format files outside of the workspace. For example, if someone is looking at a gem's source code, we
+      # don't want to format it
+      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
     end
 
@@ -380,7 +380,7 @@ module RubyLsp
 
       target, parent = document.locate_node(position)
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::DocumentHighlight.new(target, parent, dispatcher, @message_queue)
+      listener = Requests::DocumentHighlight.new(target, parent, dispatcher)
       dispatcher.visit(document.tree)
       listener.response
     end
@@ -393,7 +393,8 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::InlayHints.new(start_line..end_line, dispatcher, @message_queue)
+      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
@@ -443,6 +444,11 @@ module RubyLsp
 
     sig { params(uri: URI::Generic).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
+      # Do not compute diagnostics for files outside of the workspace. For example, if someone is looking at a gem's
+      # source code, we don't want to show diagnostics for it
+      path = uri.to_standardized_path
+      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
       end
@@ -457,11 +463,7 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::SemanticHighlighting.new(
-        dispatcher,
-        @message_queue,
-        range: start_line..end_line,
-      )
+      listener = Requests::SemanticHighlighting.new(dispatcher, range: start_line..end_line)
       dispatcher.visit(document.tree)
 
       Requests::Support::SemanticTokenEncoder.new.encode(listener.response)
@@ -513,12 +515,7 @@ module RubyLsp
       return unless target
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::Completion.new(
-        @index,
-        nesting,
-        dispatcher,
-        @message_queue,
-      )
+      listener = Requests::Completion.new(@index, nesting, dispatcher)
       dispatcher.dispatch_once(target)
       listener.response
     end
@@ -583,6 +580,9 @@ module RubyLsp
     def initialize_request(options)
       @store.clear
 
+      workspace_uri = options.dig(:workspaceFolders, 0, :uri)
+      @store.workspace_uri = URI(workspace_uri) if workspace_uri
+
       encodings = options.dig(:capabilities, :general, :positionEncodings)
       @store.encoding = if encodings.nil? || encodings.empty?
         Constant::PositionEncodingKind::UTF16
@@ -604,6 +604,11 @@ module RubyLsp
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
       @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
+      configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
+      configured_lenses = options.dig(:initializationOptions, :featuresConfiguration, :codeLens)
+      T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
+      T.must(@store.features_configuration.dig(:codeLens)).configuration.merge!(configured_lenses) if configured_lenses
+
       enabled_features = case configured_features
       when Array
         # If the configuration is using an array, then absent features are disabled and present ones are enabled. That's
@@ -665,7 +670,7 @@ module RubyLsp
       on_type_formatting_provider = if enabled_features["onTypeFormatting"]
         Interface::DocumentOnTypeFormattingOptions.new(
           first_trigger_character: "{",
-          more_trigger_character: ["\n", "|"],
+          more_trigger_character: ["\n", "|", "d"],
         )
       end
 

data/lib/ruby_lsp/listener.rb

@@ -14,10 +14,9 @@ module RubyLsp
 
     abstract!
 
-    sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-    def initialize(dispatcher, message_queue)
+    sig { params(dispatcher: Prism::Dispatcher).void }
+    def initialize(dispatcher)
       @dispatcher = dispatcher
-      @message_queue = message_queue
     end
 
     sig { returns(ResponseType) }
@@ -43,8 +42,8 @@ module RubyLsp
     # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
     # ivars have been initialized. This is because the constructor of ExtensibleListener calls
     # `initialize_external_listener` which may depend on the subclass's ivars.
-    sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-    def initialize(dispatcher, message_queue)
+    sig { params(dispatcher: Prism::Dispatcher).void }
+    def initialize(dispatcher)
       super
       @response_merged = T.let(false, T::Boolean)
       @external_listeners = T.let(

data/lib/ruby_lsp/requests/code_actions.rb

@@ -38,14 +38,8 @@ module RubyLsp
       def run
         diagnostics = @context[:diagnostics]
 
-        code_actions = diagnostics.filter_map do |diagnostic|
-          code_action = diagnostic.dig(:data, :code_action)
-          next if code_action.nil?
-
-          # We want to return only code actions that are within range or that do not have any edits, such as refactor
-          # code actions
-          range = code_action.dig(:edit, :documentChanges, 0, :edits, 0, :range)
-          code_action if diagnostic.dig(:data, :correctable) && cover?(range)
+        code_actions = diagnostics.flat_map do |diagnostic|
+          diagnostic.dig(:data, :code_actions) || []
         end
 
         # Only add refactor actions if there's a non empty selection in the editor
@@ -55,14 +49,6 @@ module RubyLsp
 
       private
 
-      sig { params(range: T.nilable(Document::RangeShape)).returns(T::Boolean) }
-      def cover?(range)
-        range.nil? ||
-          ((@range.dig(:start, :line))..(@range.dig(:end, :line))).cover?(
-            (range.dig(:start, :line))..(range.dig(:end, :line)),
-          )
-      end
-
       sig { params(range: Document::RangeShape, uri: URI::Generic).returns(Interface::CodeAction) }
       def refactor_code_action(range, uri)
         Interface::CodeAction.new(

data/lib/ruby_lsp/requests/code_lens.rb

@@ -11,6 +11,10 @@ module RubyLsp
     # [code lens](https://microsoft.github.io/language-server-protocol/specification#textDocument_codeLens)
     # request informs the editor of runnable commands such as tests
     #
+    # # Configuration
+    #
+    # To disable gem code lenses, set `rubyLsp.featuresConfiguration.codeLens.gemfileLinks` to `false`.
+    #
     # # Example
     #
     # ```ruby
@@ -47,16 +51,25 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-      def initialize(uri, dispatcher, message_queue)
+      sig do
+        params(
+          uri: URI::Generic,
+          lenses_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(uri, lenses_configuration, dispatcher)
         @uri = T.let(uri, URI::Generic)
         @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
         @class_stack = T.let([], T::Array[String])
+        @group_id = T.let(1, Integer)
+        @group_id_stack = T.let([], T::Array[Integer])
+        @lenses_configuration = lenses_configuration
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -82,12 +95,16 @@ module RubyLsp
             kind: :group,
           )
         end
+
+        @group_id_stack.push(@group_id)
+        @group_id += 1
       end
 
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_leave(node)
         @visibility_stack.pop
         @class_stack.pop
+        @group_id_stack.pop
       end
 
       sig { params(node: Prism::DefNode).void }
@@ -128,6 +145,8 @@ module RubyLsp
         end
 
         if @path&.include?(GEMFILE_NAME) && name == :gem && arguments
+          return unless @lenses_configuration.enabled?(:gemfileLinks)
+
           first_argument = arguments.arguments.first
           return unless first_argument.is_a?(Prism::StringNode)
 
@@ -146,7 +165,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_code_lens_listener(@uri, @dispatcher, @message_queue)
+        addon.create_code_lens_listener(@uri, @dispatcher)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -174,12 +193,15 @@ module RubyLsp
           },
         ]
 
+        grouping_data = { group_id: @group_id_stack.last, kind: kind }
+        grouping_data[:id] = @group_id if kind == :group
+
         @_response << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
           arguments: arguments,
-          data: { type: "test", kind: kind },
+          data: { type: "test", **grouping_data },
         )
 
         @_response << create_code_lens(
@@ -187,7 +209,7 @@ module RubyLsp
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
           arguments: arguments,
-          data: { type: "test_in_terminal", kind: kind },
+          data: { type: "test_in_terminal", **grouping_data },
         )
 
         @_response << create_code_lens(
@@ -195,7 +217,7 @@ module RubyLsp
           title: "Debug",
           command_name: "rubyLsp.debugTest",
           arguments: arguments,
-          data: { type: "debug", kind: kind },
+          data: { type: "debug", **grouping_data },
         )
       end
 

data/lib/ruby_lsp/requests/completion.rb

@@ -36,11 +36,10 @@ module RubyLsp
           index: RubyIndexer::Index,
           nesting: T::Array[String],
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(index, nesting, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      def initialize(index, nesting, dispatcher)
+        super(dispatcher)
         @_response = T.let([], ResponseType)
         @index = index
         @nesting = nesting
@@ -137,18 +136,22 @@ module RubyLsp
 
         receiver = T.must(receiver_entries.first)
 
-        candidates = T.cast(@index.prefix_search(name), T::Array[T::Array[RubyIndexer::Entry::Method]])
-        candidates.each do |entries|
-          entry = entries.find { |e| e.owner&.name == receiver.name }
+        @index.prefix_search(name).each do |entries|
+          entry = entries.find { |e| e.is_a?(RubyIndexer::Entry::Member) && e.owner&.name == receiver.name }
           next unless entry
 
-          @_response << build_method_completion(entry, node)
+          @_response << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
         end
       end
 
       private
 
-      sig { params(entry: RubyIndexer::Entry::Method, node: Prism::CallNode).returns(Interface::CompletionItem) }
+      sig do
+        params(
+          entry: RubyIndexer::Entry::Member,
+          node: Prism::CallNode,
+        ).returns(Interface::CompletionItem)
+      end
       def build_method_completion(entry, node)
         name = entry.name
         parameters = entry.parameters

data/lib/ruby_lsp/requests/definition.rb

@@ -37,16 +37,15 @@ module RubyLsp
           nesting: T::Array[String],
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(uri, nesting, index, dispatcher, message_queue)
+      def initialize(uri, nesting, index, dispatcher)
         @uri = uri
         @nesting = nesting
         @index = index
         @_response = T.let(nil, ResponseType)
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -58,7 +57,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_definition_listener(@uri, @nesting, @index, @dispatcher, @message_queue)
+        addon.create_definition_listener(@uri, @nesting, @index, @dispatcher)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -32,13 +32,8 @@ module RubyLsp
       def run
         # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
         return syntax_error_diagnostics if @document.syntax_error?
-
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
-        # Don't try to run RuboCop diagnostics for files outside the current working directory
-        path = @uri.to_standardized_path
-        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
-
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document).map!(&:to_lsp_diagnostic)
       end
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -114,11 +114,10 @@ module RubyLsp
           target: T.nilable(Prism::Node),
           parent: T.nilable(Prism::Node),
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(target, parent, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      def initialize(target, parent, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], T::Array[Interface::DocumentHighlight])
 

data/lib/ruby_lsp/requests/document_link.rb

@@ -80,11 +80,10 @@ module RubyLsp
           uri: URI::Generic,
           comments: T::Array[Prism::Comment],
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(uri, comments, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      def initialize(uri, comments, dispatcher)
+        super(dispatcher)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -49,8 +49,8 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::DocumentSymbol]) }
       attr_reader :_response
 
-      sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-      def initialize(dispatcher, message_queue)
+      sig { params(dispatcher: Prism::Dispatcher).void }
+      def initialize(dispatcher)
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @_response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
         @stack = T.let(
@@ -80,7 +80,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_document_symbol_listener(@dispatcher, @message_queue)
+        addon.create_document_symbol_listener(@dispatcher)
       end
 
       # Merges responses from other listeners

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -21,9 +21,9 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
 
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher, queue: Thread::Queue).void }
-      def initialize(comments, dispatcher, queue)
-        super(dispatcher, queue)
+      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
+      def initialize(comments, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @requires = T.let([], T::Array[Prism::CallNode])
@@ -40,6 +40,7 @@ module RubyLsp
           :on_array_node_enter,
           :on_block_node_enter,
           :on_case_node_enter,
+          :on_case_match_node_enter,
           :on_class_node_enter,
           :on_module_node_enter,
           :on_for_node_enter,
@@ -51,7 +52,6 @@ module RubyLsp
           :on_else_node_enter,
           :on_ensure_node_enter,
           :on_begin_node_enter,
-          :on_string_concat_node_enter,
           :on_def_node_enter,
           :on_call_node_enter,
           :on_lambda_node_enter,
@@ -91,10 +91,10 @@ module RubyLsp
 
       sig { params(node: Prism::InterpolatedStringNode).void }
       def on_interpolated_string_node_enter(node)
-        opening_loc = node.opening_loc
-        closing_loc = node.closing_loc
+        opening_loc = node.opening_loc || node.location
+        closing_loc = node.closing_loc || node.parts.last&.location || node.location
 
-        add_lines_range(opening_loc.start_line, closing_loc.start_line - 1) if opening_loc && closing_loc
+        add_lines_range(opening_loc.start_line, closing_loc.start_line - 1)
       end
 
       sig { params(node: Prism::ArrayNode).void }
@@ -112,6 +112,11 @@ module RubyLsp
         add_simple_range(node)
       end
 
+      sig { params(node: Prism::CaseMatchNode).void }
+      def on_case_match_node_enter(node)
+        add_simple_range(node)
+      end
+
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
         add_simple_range(node)
@@ -167,14 +172,6 @@ module RubyLsp
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::StringConcatNode).void }
-      def on_string_concat_node_enter(node)
-        left = T.let(node.left, Prism::Node)
-        left = left.left while left.is_a?(Prism::StringConcatNode)
-
-        add_lines_range(left.location.start_line, node.right.location.end_line - 1)
-      end
-
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
         params = node.parameters

data/lib/ruby_lsp/requests/formatting.rb

@@ -64,11 +64,6 @@ module RubyLsp
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
         return if @formatter == "none"
-
-        # Don't try to format files outside the current working directory
-        path = @uri.to_standardized_path
-        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
-
         return if @document.syntax_error?
 
         formatted_text = formatted_file

data/lib/ruby_lsp/requests/hover.rb

@@ -37,15 +37,14 @@ module RubyLsp
           index: RubyIndexer::Index,
           nesting: T::Array[String],
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(index, nesting, dispatcher, message_queue)
+      def initialize(index, nesting, dispatcher)
         @index = index
         @nesting = nesting
         @_response = T.let(nil, ResponseType)
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
         dispatcher.register(
           self,
           :on_constant_read_node_enter,
@@ -57,7 +56,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_hover_listener(@nesting, @index, @dispatcher, @message_queue)
+        addon.create_hover_listener(@nesting, @index, @dispatcher)
       end
 
       # Merges responses from other hover listeners

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -9,6 +9,14 @@ module RubyLsp
     # are labels added directly in the code that explicitly show the user something that might
     # otherwise just be implied.
     #
+    # # Configuration
+    #
+    # To enable rescue hints, set `rubyLsp.featuresConfiguration.inlayHint.implicitRescue` to `true`.
+    #
+    # To enable hash value hints, set `rubyLsp.featuresConfiguration.inlayHint.implicitHashValue` to `true`.
+    #
+    # To enable all hints, set `rubyLsp.featuresConfiguration.inlayHint.enableAll` to `true`.
+    #
     # # Example
     #
     # ```ruby
@@ -39,18 +47,26 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-      def initialize(range, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      sig do
+        params(
+          range: T::Range[Integer],
+          hints_configuration: RequestConfig,
+          dispatcher: Prism::Dispatcher,
+        ).void
+      end
+      def initialize(range, hints_configuration, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range
+        @hints_configuration = hints_configuration
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end
 
       sig { params(node: Prism::RescueNode).void }
       def on_rescue_node_enter(node)
+        return unless @hints_configuration.enabled?(:implicitRescue)
         return unless node.exceptions.empty?
 
         loc = node.location
@@ -66,6 +82,7 @@ module RubyLsp
 
       sig { params(node: Prism::ImplicitNode).void }
       def on_implicit_node_enter(node)
+        return unless @hints_configuration.enabled?(:implicitHashValue)
         return unless visible?(node, @range)
 
         node_value = node.value