ruby-lsp 0.23.5 → 0.23.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 924e57270229eb4d0b709b01023d16f414591f8ea40c3b8a51ae6fb6cd09cc4f
-  data.tar.gz: 72f4f544baf412f8580fe28287ba5324c7f646a9436797ebea59f34f3712d62e
+  metadata.gz: 46b72d1b9ba142496f64035b6b1ad54d096c0a28ae52311612bd118bc49e2956
+  data.tar.gz: 525dc46dcfc71ee57da51955a4034ceace3bbdd1eca7942b542ab2cd32d42ad4
 SHA512:
-  metadata.gz: 650cf172b8b1408f5498cb2010c2f94b3ef0a4bc93212ef63e24c2177ef5996455625a1bb64fe51f75322a42625e9ebcf156f95f5412c44839fe4957df4c957f
-  data.tar.gz: ce9b866443836810fe5884c2f977d4fd91fe020023ff547a9d60e525715ce388429aa7a901b0acc84876d68cada8f30dac2836494b7403fd8c2e845bea86ce79
+  metadata.gz: '06690b76d284ca6abc05fc0e836af32a54c0a3cedea1fd53071648330a3b3b6e6d1a59ef205127f54a88e8cd3ca07c3840f25f1293e37737d705b2ea41719cb1'
+  data.tar.gz: bd6104ef180f122d0bb9d6d751213c43f0d19d0f203deb50e5d94583ff0aaf85559a040ca0371fc24506ff11a0d2742c14f1277226cc34d3a09d02730d46aed7

data/README.md

@@ -4,7 +4,7 @@
 
 [![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)](https://github.com/Shopify/ruby-lsp/actions/workflows/ci.yml)
 [![Ruby LSP extension](https://img.shields.io/badge/VS%20Code-Ruby%20LSP-success?logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
-[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-2c8zjlir6-uUDJl8oIwcen_FS_aA~b6Q)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-2yd77ayis-yAiVc1TX_kH0mHMBbi89dA)
 
 # Ruby LSP
 
@@ -13,7 +13,7 @@ for Ruby, used to improve rich features in editors. It is a part of a wider goal
 experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
 Want to discuss Ruby developer experience? Consider joining the public
-[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-2c8zjlir6-uUDJl8oIwcen_FS_aA~b6Q).
+[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-2yd77ayis-yAiVc1TX_kH0mHMBbi89dA).
 
 ## Getting Started
 

data/VERSION

@@ -1 +1 @@
-0.23.5
+0.23.7

data/exe/ruby-lsp

@@ -64,9 +64,9 @@ if ENV["BUNDLE_GEMFILE"].nil?
   # which gives us the opportunity to control which specs are activated and enter degraded mode if any gems failed to
   # install rather than failing to boot the server completely
   if options[:launcher]
-    command = +"#{Gem.ruby} #{File.expand_path("ruby-lsp-launcher", __dir__)}"
-    command << " --debug" if options[:debug]
-    exit exec(command)
+    flags = []
+    flags << "--debug" if options[:debug]
+    exit exec(Gem.ruby, File.expand_path("ruby-lsp-launcher", __dir__), *flags)
   end
 
   require_relative "../lib/ruby_lsp/setup_bundler"

data/exe/ruby-lsp-launcher

@@ -8,14 +8,24 @@
 
 setup_error = nil
 install_error = nil
+reboot = false
 
-# Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
-# Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
-# to ensure that we're setting up the bundle in the right place
-$stdin.binmode
-headers = $stdin.gets("\r\n\r\n")
-content_length = headers[/Content-Length: (\d+)/i, 1].to_i
-raw_initialize = $stdin.read(content_length)
+workspace_uri = ARGV.first
+
+raw_initialize = if workspace_uri && !workspace_uri.start_with?("--")
+  # If there's an argument without `--`, then it's the server asking to compose the bundle and passing to this
+  # executable the workspace URI. We can't require gems at this point, so we built a fake initialize request manually
+  reboot = true
+  "{\"params\":{\"workspaceFolders\":[{\"uri\":\"#{workspace_uri}\"}]}}"
+else
+  # Read the initialize request before even starting the server. We need to do this to figure out the workspace URI.
+  # Editors are not required to spawn the language server process on the same directory as the workspace URI, so we need
+  # to ensure that we're setting up the bundle in the right place
+  $stdin.binmode
+  headers = $stdin.gets("\r\n\r\n")
+  content_length = headers[/Content-Length: (\d+)/i, 1].to_i
+  $stdin.read(content_length)
+end
 
 # Compose the Ruby LSP bundle in a forked process so that we can require gems without polluting the main process
 # `$LOAD_PATH` and `Gem.loaded_specs`. Windows doesn't support forking, so we need a separate path to support it
@@ -91,6 +101,13 @@ rescue StandardError => e
   $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 end
 
+# When performing a lockfile re-boot, this executable is invoked to set up the composed bundle ahead of time. In this
+# flow, we are not booting the LSP yet, just checking if the bundle is valid before rebooting
+if reboot
+  # Use the exit status to signal to the server if composing the bundle succeeded
+  exit(install_error || setup_error ? 1 : 0)
+end
+
 # Now that the bundle is set up, we can begin actually launching the server. Note that `Bundler.setup` will have already
 # configured the load path using the version of the Ruby LSP present in the composed bundle. Do not push any Ruby LSP
 # paths into the load path manually or we may end up requiring the wrong version of the gem

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/code_actions.rb

@@ -19,7 +19,7 @@ module RubyLsp
         sig { returns(Interface::CodeActionRegistrationOptions) }
         def provider
           Interface::CodeActionRegistrationOptions.new(
-            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            document_selector: nil,
             resolve_provider: true,
           )
         end

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -15,7 +15,7 @@ module RubyLsp
         sig { returns(Interface::DiagnosticRegistrationOptions) }
         def provider
           Interface::DiagnosticRegistrationOptions.new(
-            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            document_selector: nil,
             inter_file_dependencies: false,
             workspace_diagnostics: false,
           )

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -13,13 +13,9 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(Interface::FoldingRangeRegistrationOptions) }
+        sig { returns(TrueClass) }
         def provider
-          Interface::FoldingRangeRegistrationOptions.new(
-            document_selector: [
-              Interface::DocumentFilter.new(language: "ruby"),
-            ],
-          )
+          true
         end
       end
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -14,13 +14,9 @@ module RubyLsp
       class << self
         extend T::Sig
 
-        sig { returns(Interface::DocumentFormattingRegistrationOptions) }
+        sig { returns(TrueClass) }
         def provider
-          Interface::DocumentFormattingRegistrationOptions.new(
-            document_selector: [
-              Interface::DocumentFilter.new(language: "ruby"),
-            ],
-          )
+          true
         end
       end
 

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -14,7 +14,7 @@ module RubyLsp
         sig { returns(Interface::DocumentOnTypeFormattingRegistrationOptions) }
         def provider
           Interface::DocumentOnTypeFormattingRegistrationOptions.new(
-            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            document_selector: nil,
             first_trigger_character: "{",
             more_trigger_character: ["\n", "|", "d"],
           )

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/requests/semantic_highlighting.rb

@@ -17,7 +17,7 @@ module RubyLsp
         sig { returns(Interface::SemanticTokensRegistrationOptions) }
         def provider
           Interface::SemanticTokensRegistrationOptions.new(
-            document_selector: [{ language: "ruby" }, { language: "erb" }],
+            document_selector: nil,
             legend: Interface::SemanticTokensLegend.new(
               token_types: ResponseBuilders::SemanticHighlighting::TOKEN_TYPES.keys,
               token_modifiers: ResponseBuilders::SemanticHighlighting::TOKEN_MODIFIERS.keys,

data/lib/ruby_lsp/server.rb

@@ -106,6 +106,8 @@ module RubyLsp
               end,
           ),
         )
+      when "rubyLsp/composeBundle"
+        compose_bundle(message)
       when "$/cancelRequest"
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
@@ -283,6 +285,7 @@ module RubyLsp
           document_range_formatting_provider: true,
           experimental: {
             addon_detection: true,
+            compose_bundle: true,
           },
         ),
         serverInfo: {
@@ -338,7 +341,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 +1042,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 +1218,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,
           ),
         )
@@ -1279,5 +1285,37 @@ module RubyLsp
 
       addon.handle_window_show_message_response(result[:title])
     end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def compose_bundle(message)
+      already_composed_path = File.join(@global_state.workspace_path, ".ruby-lsp", "bundle_is_composed")
+      command = "#{Gem.ruby} #{File.expand_path("../../exe/ruby-lsp-launcher", __dir__)} #{@global_state.workspace_uri}"
+      id = message[:id]
+
+      begin
+        Bundler::LockfileParser.new(Bundler.default_lockfile.read)
+      rescue Bundler::LockfileError => e
+        send_message(Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: e.message))
+        return
+      end
+
+      # We compose the bundle in a thread so that the LSP continues to work while we're checking for its validity. Once
+      # we return the response back to the editor, then the restart is triggered
+      Thread.new do
+        send_log_message("Recomposing the bundle ahead of restart")
+        pid = Process.spawn(command)
+        _, status = Process.wait2(pid)
+
+        if status&.exitstatus == 0
+          # Create a signal for the restart that it can skip composing the bundle and launch directly
+          FileUtils.touch(already_composed_path)
+          send_message(Result.new(id: id, response: { success: true }))
+        else
+          # This special error code makes the extension avoid restarting in case we already know that the composed
+          # bundle is not valid
+          send_message(Error.new(id: id, code: BUNDLE_COMPOSE_FAILED_CODE, message: "Failed to compose bundle"))
+        end
+      end
+    end
   end
 end

data/lib/ruby_lsp/setup_bundler.rb

@@ -57,6 +57,7 @@ module RubyLsp
       @lockfile_hash_path = T.let(@custom_dir + "main_lockfile_hash", Pathname)
       @last_updated_path = T.let(@custom_dir + "last_updated", Pathname)
       @error_path = T.let(@custom_dir + "install_error", Pathname)
+      @already_composed_path = T.let(@custom_dir + "bundle_is_composed", Pathname)
 
       dependencies, bundler_version = load_dependencies
       @dependencies = T.let(dependencies, T::Hash[String, T.untyped])
@@ -71,6 +72,23 @@ module RubyLsp
     def setup!
       raise BundleNotLocked if !@launcher && @gemfile&.exist? && !@lockfile&.exist?
 
+      # If the bundle was composed ahead of time using our custom `rubyLsp/composeBundle` request, then we can skip the
+      # entire process and just return the composed environment
+      if @already_composed_path.exist?
+        $stderr.puts("Ruby LSP> Composed bundle was set up ahead of time. Skipping...")
+        @already_composed_path.delete
+
+        env = bundler_settings_as_env
+        env["BUNDLE_GEMFILE"] = @custom_gemfile.exist? ? @custom_gemfile.to_s : @gemfile.to_s
+
+        if env["BUNDLE_PATH"]
+          env["BUNDLE_PATH"] = File.expand_path(env["BUNDLE_PATH"], @project_path)
+        end
+
+        env["BUNDLER_VERSION"] = @bundler_version.to_s if @bundler_version
+        return env
+      end
+
       # Automatically create and ignore the .ruby-lsp folder for users
       @custom_dir.mkpath unless @custom_dir.exist?
       ignore_file = @custom_dir + ".gitignore"

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
@@ -37,6 +37,8 @@ module RubyLsp
     CODE = -32900
   end
 
+  BUNDLE_COMPOSE_FAILED_CODE = -33000
+
   # A notification to be sent to the client
   class Message
     extend T::Sig
@@ -162,7 +164,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 +210,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.7
 platform: ruby
 authors:
 - Shopify
 bindir: exe
 cert_chain: []
-date: 2025-01-10 00:00:00.000000000 Z
+date: 2025-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -218,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: An opinionated language server for Ruby
 test_files: []