ruby-lsp 0.23.5 → 0.23.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 924e57270229eb4d0b709b01023d16f414591f8ea40c3b8a51ae6fb6cd09cc4f
-  data.tar.gz: 72f4f544baf412f8580fe28287ba5324c7f646a9436797ebea59f34f3712d62e
+  metadata.gz: 563db8ddc06dc53f37db5ea4a42a48b7af8ed5bb2639c42e87e3c2bdd7fe38d1
+  data.tar.gz: a1820031a007e14c42600fd897e43fad044f26e05f02e117c806821cdc46e9d7
 SHA512:
-  metadata.gz: 650cf172b8b1408f5498cb2010c2f94b3ef0a4bc93212ef63e24c2177ef5996455625a1bb64fe51f75322a42625e9ebcf156f95f5412c44839fe4957df4c957f
-  data.tar.gz: ce9b866443836810fe5884c2f977d4fd91fe020023ff547a9d60e525715ce388429aa7a901b0acc84876d68cada8f30dac2836494b7403fd8c2e845bea86ce79
+  metadata.gz: 2d28983a474a7b32486f20df65ec2a808ddf2be31bc0c4d7d62ae1c3fa24448b28699917d23b6f4f00045ff45e25aeff1e27c6a27d40c6a7dc6887be630f8828
+  data.tar.gz: d10bd35268476cd2b2d319405dd58433d32df48a621cf4d45555cafb6e293d3bc4b3844afe7bf6dc0d39e68a5f5a7be70b935874796a3852a68ac5c61c592709

data/VERSION

@@ -1 +1 @@
-0.23.5
+0.23.6

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -143,7 +143,7 @@ module RubyIndexer
 
       if current_owner
         expression = node.expression
-        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{@stack.last}>" : "<Class:#{expression.slice}>")
+        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
         real_nesting = actual_nesting(name)
 
         existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
@@ -376,7 +376,6 @@ module RubyIndexer
         ))
 
         @owner_stack << singleton
-        @stack << "<Class:#{@stack.last}>"
       end
     end
 
@@ -386,7 +385,6 @@ module RubyIndexer
 
       if node.receiver.is_a?(Prism::SelfNode)
         @owner_stack.pop
-        @stack.pop
       end
     end
 
@@ -1127,5 +1125,15 @@ module RubyIndexer
       @index.add(entry)
       @stack << short_name
     end
+
+    # Returns the last name in the stack not as we found it, but in terms of declared constants. For example, if the
+    # last entry in the stack is a compact namespace like `Foo::Bar`, then the last name is `Bar`
+    sig { returns(T.nilable(String)) }
+    def last_name_in_stack
+      name = @stack.last
+      return unless name
+
+      name.split("::").last
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -37,6 +37,19 @@ module RubyIndexer
       end
     end
 
+    class InstanceVariableTarget < Target
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        super()
+        @name = name
+      end
+    end
+
     class Reference
       extend T::Sig
 
@@ -94,6 +107,12 @@ module RubyIndexer
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
         :on_constant_operator_write_node_enter,
+        :on_instance_variable_read_node_enter,
+        :on_instance_variable_write_node_enter,
+        :on_instance_variable_and_write_node_enter,
+        :on_instance_variable_operator_write_node_enter,
+        :on_instance_variable_or_write_node_enter,
+        :on_instance_variable_target_node_enter,
         :on_call_node_enter,
       )
     end
@@ -262,6 +281,36 @@ module RubyIndexer
       end
     end
 
+    sig { params(node: Prism::InstanceVariableReadNode).void }
+    def on_instance_variable_read_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.location, false)
+    end
+
+    sig { params(node: Prism::InstanceVariableWriteNode).void }
+    def on_instance_variable_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+    def on_instance_variable_and_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+    def on_instance_variable_operator_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+    def on_instance_variable_or_write_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
+    end
+
+    sig { params(node: Prism::InstanceVariableTargetNode).void }
+    def on_instance_variable_target_node_enter(node)
+      collect_instance_variable_references(node.name.to_s, node.location, true)
+    end
+
     sig { params(node: Prism::CallNode).void }
     def on_call_node_enter(node)
       if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
@@ -305,6 +354,13 @@ module RubyIndexer
       end
     end
 
+    sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+    def collect_instance_variable_references(name, location, declaration)
+      return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
+
+      @references << Reference.new(name, location, declaration: declaration)
+    end
+
     sig do
       params(
         node: T.any(

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -647,5 +647,24 @@ module RubyIndexer
       entry = @index["Foo"].first
       assert_empty(entry.comments)
     end
+
+    def test_singleton_inside_compact_namespace
+      index(<<~RUBY)
+        module Foo::Bar
+          class << self
+            def baz; end
+          end
+        end
+      RUBY
+
+      # Verify we didn't index the incorrect name
+      assert_nil(@index["Foo::Bar::<Class:Foo::Bar>"])
+
+      # Verify we indexed the correct name
+      assert_entry("Foo::Bar::<Class:Bar>", Entry::SingletonClass, "/fake/path/foo.rb:1-2:3-5")
+
+      method = @index["baz"]&.first
+      assert_equal("Foo::Bar::<Class:Bar>", method.owner.name)
+    end
   end
 end

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -216,6 +216,64 @@ module RubyIndexer
       assert_equal(11, refs[2].location.start_line)
     end
 
+    def test_finds_instance_variable_read_references
+      refs = find_instance_variable_references("@foo", <<~RUBY)
+        class Foo
+          def foo
+            @foo
+          end
+        end
+      RUBY
+      assert_equal(1, refs.size)
+
+      assert_equal("@foo", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+    end
+
+    def test_finds_instance_variable_write_references
+      refs = find_instance_variable_references("@foo", <<~RUBY)
+        class Foo
+          def write
+            @foo = 1
+            @foo &&= 2
+            @foo ||= 3
+            @foo += 4
+            @foo, @bar = []
+          end
+        end
+      RUBY
+      assert_equal(5, refs.size)
+
+      assert_equal(["@foo"], refs.map(&:name).uniq)
+      assert_equal(3, refs[0].location.start_line)
+      assert_equal(4, refs[1].location.start_line)
+      assert_equal(5, refs[2].location.start_line)
+      assert_equal(6, refs[3].location.start_line)
+      assert_equal(7, refs[4].location.start_line)
+    end
+
+    def test_finds_instance_variable_references_ignore_context
+      refs = find_instance_variable_references("@name", <<~RUBY)
+        class Foo
+          def name
+            @name = "foo"
+          end
+        end
+        class Bar
+          def name
+            @name = "bar"
+          end
+        end
+      RUBY
+      assert_equal(2, refs.size)
+
+      assert_equal("@name", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("@name", refs[1].name)
+      assert_equal(8, refs[1].location.start_line)
+    end
+
     private
 
     def find_const_references(const_name, source)
@@ -228,6 +286,11 @@ module RubyIndexer
       find_references(target, source)
     end
 
+    def find_instance_variable_references(instance_variable_name, source)
+      target = ReferenceFinder::InstanceVariableTarget.new(instance_variable_name)
+      find_references(target, source)
+    end
+
     def find_references(target, source)
       file_path = "/fake.rb"
       index = Index.new

data/lib/ruby_lsp/client_capabilities.rb

@@ -11,7 +11,8 @@ module RubyLsp
     attr_reader :supports_watching_files,
       :supports_request_delegation,
       :window_show_message_supports_extra_properties,
-      :supports_progress
+      :supports_progress,
+      :supports_diagnostic_refresh
 
     sig { void }
     def initialize
@@ -32,6 +33,9 @@ module RubyLsp
 
       # The editor supports displaying progress requests
       @supports_progress = T.let(false, T::Boolean)
+
+      # The editor supports server initiated refresh for diagnostics
+      @supports_diagnostic_refresh = T.let(false, T::Boolean)
     end
 
     sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
@@ -57,6 +61,8 @@ module RubyLsp
 
       progress = capabilities.dig(:window, :workDoneProgress)
       @supports_progress = progress if progress
+
+      @supports_diagnostic_refresh = workspace_capabilities.dig(:diagnostics, :refreshSupport) || false
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -94,6 +94,8 @@ module RubyLsp
       @workspace_uri = URI(workspace_uri) if workspace_uri
 
       specified_formatter = options.dig(:initializationOptions, :formatter)
+      rubocop_has_addon = defined?(::RuboCop::Version::STRING) &&
+        Gem::Requirement.new(">= 1.70.0").satisfied_by?(Gem::Version.new(::RuboCop::Version::STRING))
 
       if specified_formatter
         @formatter = specified_formatter
@@ -101,6 +103,12 @@ module RubyLsp
         if specified_formatter != "auto"
           notifications << Notification.window_log_message("Using formatter specified by user: #{@formatter}")
         end
+
+        # If the user had originally configured to use `rubocop`, but their version doesn't provide the add-on yet,
+        # fallback to the internal integration
+        if specified_formatter == "rubocop" && !rubocop_has_addon
+          @formatter = "rubocop_internal"
+        end
       end
 
       if @formatter == "auto"
@@ -109,6 +117,23 @@ module RubyLsp
       end
 
       specified_linters = options.dig(:initializationOptions, :linters)
+
+      if specified_formatter == "rubocop" || specified_linters&.include?("rubocop")
+        notifications << Notification.window_log_message(<<~MESSAGE, type: Constant::MessageType::WARNING)
+          Formatter is configured to be `rubocop`. As of RuboCop v1.70.0, this identifier activates the add-on
+          implemented in the rubocop gem itself instead of the internal integration provided by the Ruby LSP.
+
+          If you wish to use the internal integration, please configure the formatter as `rubocop_internal`.
+        MESSAGE
+      end
+
+      # If the user had originally configured to use `rubocop`, but their version doesn't provide the add-on yet,
+      # fall back to the internal integration
+      if specified_linters&.include?("rubocop") && !rubocop_has_addon
+        specified_linters.delete("rubocop")
+        specified_linters << "rubocop_internal"
+      end
+
       @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
 
       notifications << if specified_linters
@@ -185,13 +210,13 @@ module RubyLsp
     sig { params(direct_dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(String) }
     def detect_formatter(direct_dependencies, all_dependencies)
       # NOTE: Intentionally no $ at end, since we want to match rubocop-shopify, etc.
-      return "rubocop" if direct_dependencies.any?(/^rubocop/)
+      return "rubocop_internal" if direct_dependencies.any?(/^rubocop/)
 
       syntax_tree_is_direct_dependency = direct_dependencies.include?("syntax_tree")
       return "syntax_tree" if syntax_tree_is_direct_dependency
 
       rubocop_is_transitive_dependency = all_dependencies.include?("rubocop")
-      return "rubocop" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
+      return "rubocop_internal" if dot_rubocop_yml_present && rubocop_is_transitive_dependency
 
       "none"
     end
@@ -203,7 +228,7 @@ module RubyLsp
       linters = []
 
       if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
-        linters << "rubocop"
+        linters << "rubocop_internal"
       end
 
       linters

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -120,7 +120,7 @@ module RubyLsp
             [target, node_value(target)]
           when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode, Prism::DefNode, Prism::CaseNode,
             Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode
-            target
+            [target, nil]
           end
 
         @target = T.let(highlight_target, T.nilable(Prism::Node))
@@ -620,7 +620,8 @@ module RubyLsp
 
       sig { params(keyword_loc: T.nilable(Prism::Location), end_loc: T.nilable(Prism::Location)).void }
       def add_matching_end_highlights(keyword_loc, end_loc)
-        return unless keyword_loc && end_loc && end_loc.length.positive?
+        return unless keyword_loc && end_loc
+        return unless end_loc.length.positive?
         return unless covers_target_position?(keyword_loc) || covers_target_position?(end_loc)
 
         add_highlight(Constant::DocumentHighlightKind::TEXT, keyword_loc)

data/lib/ruby_lsp/listeners/document_link.rb

@@ -128,7 +128,13 @@ module RubyLsp
         gem_version = resolve_version(uri)
         return if gem_version.nil?
 
-        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, CGI.unescape(uri.path))
+        path = uri.path
+        return unless path
+
+        gem_name = uri.gem_name
+        return unless gem_name
+
+        file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
         return if file_path.nil?
 
         @response_builder << Interface::DocumentLink.new(
@@ -149,7 +155,10 @@ module RubyLsp
 
         return @gem_version unless @gem_version.nil? || @gem_version.empty?
 
-        GEM_TO_VERSION_MAP[uri.gem_name]
+        gem_name = uri.gem_name
+        return unless gem_name
+
+        GEM_TO_VERSION_MAP[gem_name]
       end
     end
   end

data/lib/ruby_lsp/load_sorbet.rb

@@ -6,11 +6,11 @@ require "sorbet-runtime"
 begin
   T::Configuration.default_checked_level = :never
   # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*) {}
+  T::Configuration.call_validation_error_handler = ->(*arg) {}
   # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
+  T::Configuration.inline_type_error_handler = ->(*arg) {}
   # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
+  T::Configuration.sig_validation_error_handler = ->(*arg) {}
 rescue
   # Need this rescue so that if another gem has
   # already set the checked level by the time we

data/lib/ruby_lsp/requests/references.rb

@@ -39,6 +39,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
             Prism::CallNode,
             Prism::DefNode,
           ],
@@ -62,6 +68,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
             Prism::CallNode,
             Prism::DefNode,
           ),
@@ -97,6 +109,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
             Prism::CallNode,
             Prism::DefNode,
           ),
@@ -114,6 +132,14 @@ module RubyLsp
 
           fully_qualified_name = T.must(entries.first).name
           RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        when
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableReadNode,
+          Prism::InstanceVariableTargetNode,
+          Prism::InstanceVariableWriteNode
+          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s)
         when Prism::CallNode, Prism::DefNode
           RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
         end

data/lib/ruby_lsp/server.rb

@@ -338,7 +338,7 @@ module RubyLsp
       unless @setup_error
         if defined?(Requests::Support::RuboCopFormatter)
           begin
-            @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
+            @global_state.register_formatter("rubocop_internal", Requests::Support::RuboCopFormatter.new)
           rescue ::RuboCop::Error => e
             # The user may have provided unknown config switches in .rubocop or
             # is trying to load a non-existent config file.
@@ -1039,16 +1039,20 @@ module RubyLsp
     def handle_rubocop_config_change(uri)
       return unless defined?(Requests::Support::RuboCopFormatter)
 
-      send_log_message("Reloading RuboCop since #{uri} changed")
-      @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
+      # Register a new runner to reload configurations
+      @global_state.register_formatter("rubocop_internal", Requests::Support::RuboCopFormatter.new)
 
-      # Clear all existing diagnostics since the config changed. This has to happen under a mutex because the `state`
-      # hash cannot be mutated during iteration or that will throw an error
+      # Clear all document caches for pull diagnostics
       @global_state.synchronize do
-        @store.each do |uri, _document|
-          send_message(Notification.publish_diagnostics(uri.to_s, []))
+        @store.each do |_uri, document|
+          document.cache_set("textDocument/diagnostic", Document::EMPTY_CACHE)
         end
       end
+
+      # Request a pull diagnostic refresh from the editor
+      if @global_state.client_capabilities.supports_diagnostic_refresh
+        send_message(Request.new(id: @current_request_id, method: "workspace/diagnostic/refresh", params: nil))
+      end
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -1211,16 +1215,15 @@ module RubyLsp
     sig { void }
     def check_formatter_is_available
       return if @setup_error
-      # Warn of an unavailable `formatter` setting, e.g. `rubocop` on a project which doesn't have RuboCop.
-      # Syntax Tree will always be available via Ruby LSP so we don't need to check for it.
-      return unless @global_state.formatter == "rubocop"
+      # Warn of an unavailable `formatter` setting, e.g. `rubocop_internal` on a project which doesn't have RuboCop.
+      return unless @global_state.formatter == "rubocop_internal"
 
       unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
         @global_state.formatter = "none"
 
         send_message(
           Notification.window_show_message(
-            "Ruby LSP formatter is set to `rubocop` but RuboCop was not found in the Gemfile or gemspec.",
+            "Ruby LSP formatter is set to `rubocop_internal` but RuboCop was not found in the Gemfile or gemspec.",
             type: Constant::MessageType::ERROR,
           ),
         )

data/lib/ruby_lsp/utils.rb

@@ -25,7 +25,7 @@ module RubyLsp
     end,
     String,
   )
-  GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/design-and-roadmap.html#guessed-types"
+  GUESSED_TYPES_URL = "https://shopify.github.io/ruby-lsp/#guessed-types"
 
   # Request delegation for embedded languages is not yet standardized into the language server specification. Here we
   # use this custom error class as a way to return a signal to the client that the request should be delegated to the
@@ -162,7 +162,9 @@ module RubyLsp
 
     sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def to_hash
-      { method: @method, params: T.unsafe(@params).to_hash }
+      hash = { method: @method }
+      hash[:params] = T.unsafe(@params).to_hash if @params
+      hash
     end
   end
 
@@ -206,7 +208,9 @@ module RubyLsp
 
     sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def to_hash
-      { id: @id, method: @method, params: T.unsafe(@params).to_hash }
+      hash = { id: @id, method: @method }
+      hash[:params] = T.unsafe(@params).to_hash if @params
+      hash
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.23.5
+  version: 0.23.6
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-10 00:00:00.000000000 Z
+date: 2025-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol