ruby-lsp 0.12.4 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70a84356e392893c6f7b20e1701ef31621d9902af3a120c7013a13f80ec09568
-  data.tar.gz: bd360c2a5426631816f227ff115af967813ae7284d0a61845daf743b0a99d948
+  metadata.gz: d6bace664e1540c1333df9dabfb2e7bdd8bda0f910033b47b188e4a82ddacb15
+  data.tar.gz: be9e5da0492b26b5cb6e07074d01d7874104b70286c1578342b9639158fed147
 SHA512:
-  metadata.gz: 598494207add9412e909836e65f6288403189133711dbb17e39663eecc719089dba9f8e758069fda91666715d8c8fc5326055192ba5558f6d8151bbc21f40338
-  data.tar.gz: b86880d5b342e817d8cda46c4977a4229896d19b1fa495c6235f4d86ba74fa1a8ec737b7bad8a19af8859f315980f491b7bd8bcd8f25c1ad21d1ec3f119b9aaf
+  metadata.gz: 7d8e61433686271a68dafe8db79765ed509a115ab6f06060d7669d279f48218fe2eada2c12e3b45f155d27a41774771681cdab92700d27f426e75ed89287ca03
+  data.tar.gz: 611c050b751050934d0fd93e9e52089fe63fc4d947be75a440dfa0465933814d2682268a10135d036c2cee83fa739156d2b11e42e679ecbed7de62acfee9d621

data/VERSION

@@ -1 +1 @@
-0.12.4
+0.13.0

data/exe/ruby-lsp-check

@@ -17,8 +17,6 @@ end
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 require "ruby_lsp/internal"
 
-RubyLsp::Addon.load_addons
-
 T::Utils.run_all_sig_blocks
 
 files = Dir.glob("#{Dir.pwd}/**/*.rb")
@@ -28,6 +26,7 @@ puts "Verifying that all automatic LSP requests execute successfully. This may t
 errors = {}
 store = RubyLsp::Store.new
 message_queue = Thread::Queue.new
+RubyLsp::Addon.load_addons(message_queue)
 executor = RubyLsp::Executor.new(store, message_queue)
 
 files.each_with_index do |file, index|
@@ -50,13 +49,30 @@ end
 puts "\n"
 message_queue.close
 
+# Indexing
+puts "Verifying that indexing executes successfully. This may take a while..."
+
+index = RubyIndexer::Index.new
+indexables = RubyIndexer.configuration.indexables
+
+indexables.each_with_index do |indexable, i|
+  result = Prism.parse(File.read(indexable.full_path))
+  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
+  collector.collect(result.value)
+rescue => e
+  errors[indexable.full_path] = e
+ensure
+  print("\033[M\033[0KIndexed #{i + 1}/#{indexables.length}") unless ENV["CI"]
+end
+puts "\n"
+
 if errors.empty?
-  puts "All automatic LSP requests executed successfully"
+  puts "All operations completed successfully!"
   exit
 end
 
 puts <<~ERRORS
-  Errors while executing requests:
+  Errors while executing:
 
   #{errors.map { |file, error| "#{file}: #{error.message}" }.join("\n")}
 ERRORS

data/lib/ruby_indexer/lib/ruby_indexer/collector.rb

@@ -141,8 +141,18 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_call_node(node)
-      message = node.message
-      handle_private_constant(node) if message == "private_constant"
+      message = node.name
+
+      case message
+      when :private_constant
+        handle_private_constant(node)
+      when :attr_reader
+        handle_attribute(node, reader: true, writer: false)
+      when :attr_writer
+        handle_attribute(node, reader: false, writer: true)
+      when :attr_accessor
+        handle_attribute(node, reader: true, writer: true)
+      end
     end
 
     sig { params(node: Prism::DefNode).void }
@@ -312,5 +322,29 @@ module RubyIndexer
         "#{@stack.join("::")}::#{name}"
       end.delete_prefix("::")
     end
+
+    sig { params(node: Prism::CallNode, reader: T::Boolean, writer: T::Boolean).void }
+    def handle_attribute(node, reader:, writer:)
+      arguments = node.arguments&.arguments
+      return unless arguments
+
+      receiver = node.receiver
+      return unless receiver.nil? || receiver.is_a?(Prism::SelfNode)
+
+      comments = collect_comments(node)
+      arguments.each do |argument|
+        name, loc = case argument
+        when Prism::SymbolNode
+          [argument.value, argument.value_loc]
+        when Prism::StringNode
+          [argument.content, argument.content_loc]
+        end
+
+        next unless name && loc
+
+        @index << Entry::Accessor.new(name, @file_path, loc, comments, @current_owner) if reader
+        @index << Entry::Accessor.new("#{name}=", @file_path, loc, comments, @current_owner) if writer
+      end
+    end
   end
 end

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

@@ -120,7 +120,7 @@ module RubyIndexer
               IndexablePath.new(RbConfig::CONFIG["rubylibdir"], path)
             end,
           )
-        else
+        elsif pathname.extname == ".rb"
           # If the default_path is a Ruby file, we index it
           indexables << IndexablePath.new(RbConfig::CONFIG["rubylibdir"], default_path)
         end

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

@@ -90,20 +90,69 @@ module RubyIndexer
       end
     end
 
+    # A required method parameter, e.g. `def foo(a)`
     class RequiredParameter < Parameter
     end
 
-    class Method < Entry
+    # An optional method parameter, e.g. `def foo(a = 123)`
+    class OptionalParameter < Parameter
+    end
+
+    # An required keyword method parameter, e.g. `def foo(a:)`
+    class KeywordParameter < Parameter
+    end
+
+    # An optional keyword method parameter, e.g. `def foo(a: 123)`
+    class OptionalKeywordParameter < Parameter
+    end
+
+    class Member < Entry
       extend T::Sig
       extend T::Helpers
-      abstract!
 
-      sig { returns(T::Array[Parameter]) }
-      attr_reader :parameters
+      abstract!
 
       sig { returns(T.nilable(Entry::Namespace)) }
       attr_reader :owner
 
+      sig do
+        params(
+          name: String,
+          file_path: String,
+          location: Prism::Location,
+          comments: T::Array[String],
+          owner: T.nilable(Entry::Namespace),
+        ).void
+      end
+      def initialize(name, file_path, location, comments, owner)
+        super(name, file_path, location, comments)
+        @owner = owner
+      end
+
+      sig { abstract.returns(T::Array[Parameter]) }
+      def parameters; end
+    end
+
+    class Accessor < Member
+      extend T::Sig
+
+      sig { override.returns(T::Array[Parameter]) }
+      def parameters
+        params = []
+        params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
+        params
+      end
+    end
+
+    class Method < Member
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { override.returns(T::Array[Parameter]) }
+      attr_reader :parameters
+
       sig do
         params(
           name: String,
@@ -115,9 +164,9 @@ module RubyIndexer
         ).void
       end
       def initialize(name, file_path, location, comments, parameters_node, owner) # rubocop:disable Metrics/ParameterLists
-        super(name, file_path, location, comments)
+        super(name, file_path, location, comments, owner)
+
         @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
-        @owner = owner
       end
 
       private
@@ -126,20 +175,42 @@ module RubyIndexer
       def list_params(parameters_node)
         return [] unless parameters_node
 
-        parameters_node.requireds.filter_map do |required|
+        parameters = []
+
+        parameters_node.requireds.each do |required|
           name = parameter_name(required)
           next unless name
 
-          RequiredParameter.new(name: name)
+          parameters << RequiredParameter.new(name: name)
         end
-      end
 
-      sig do
-        params(node: Prism::Node).returns(T.nilable(Symbol))
+        parameters_node.optionals.each do |optional|
+          name = parameter_name(optional)
+          next unless name
+
+          parameters << OptionalParameter.new(name: name)
+        end
+
+        parameters_node.keywords.each do |keyword|
+          name = parameter_name(keyword)
+          next unless name
+
+          case keyword
+          when Prism::RequiredKeywordParameterNode
+            parameters << KeywordParameter.new(name: name)
+          when Prism::OptionalKeywordParameterNode
+            parameters << OptionalKeywordParameter.new(name: name)
+          end
+        end
+
+        parameters
       end
+
+      sig { params(node: Prism::Node).returns(T.nilable(Symbol)) }
       def parameter_name(node)
         case node
-        when Prism::RequiredParameterNode
+        when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode
           node.name
         when Prism::MultiTargetNode
           names = [*node.lefts, *node.rest, *node.rights].map { |parameter_node| parameter_name(parameter_node) }

data/lib/ruby_indexer/test/configuration_test.rb

@@ -84,6 +84,16 @@ module RubyIndexer
       )
     end
 
+    def test_indexables_does_not_include_non_ruby_files_inside_rubylibdir
+      path = Pathname.new(RbConfig::CONFIG["rubylibdir"]).join("extra_file.txt").to_s
+      FileUtils.touch(path)
+      indexables = @config.indexables
+
+      assert(indexables.none? { |indexable| indexable.full_path == path })
+    ensure
+      FileUtils.rm(T.must(path))
+    end
+
     def test_paths_are_unique
       @config.load_config
       indexables = @config.indexables

data/lib/ruby_indexer/test/index_test.rb

@@ -246,5 +246,16 @@ module RubyIndexer
       entry = T.must(entries.first).first
       assert_equal("baz", entry.name)
     end
+
+    def test_indexing_prism_fixtures_succeeds
+      fixtures = Dir.glob("test/fixtures/prism/test/prism/fixtures/**/*.txt")
+
+      fixtures.each do |fixture|
+        indexable_path = IndexablePath.new("", fixture)
+        @index.index_single(indexable_path)
+      end
+
+      refute_empty(@index.instance_variable_get(:@entries))
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -70,6 +70,42 @@ module RubyIndexer
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
 
+    def test_method_with_optional_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a = 123)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(1, entry.parameters.length)
+      parameter = entry.parameters.first
+      assert_equal(:a, parameter.name)
+      assert_instance_of(Entry::OptionalParameter, parameter)
+    end
+
+    def test_method_with_keyword_parameters
+      index(<<~RUBY)
+        class Foo
+          def bar(a:, b: 123)
+          end
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+      entry = T.must(@index["bar"].first)
+      assert_equal(2, entry.parameters.length)
+      a, b = entry.parameters
+
+      assert_equal(:a, a.name)
+      assert_instance_of(Entry::KeywordParameter, a)
+
+      assert_equal(:b, b.name)
+      assert_instance_of(Entry::OptionalKeywordParameter, b)
+    end
+
     def test_keeps_track_of_method_owner
       index(<<~RUBY)
         class Foo
@@ -83,5 +119,35 @@ module RubyIndexer
 
       assert_equal("Foo", owner_name)
     end
+
+    def test_keeps_track_of_attributes
+      index(<<~RUBY)
+        class Foo
+          # Hello there
+          attr_reader :bar, :other
+          attr_writer :baz
+          attr_accessor :qux
+        end
+      RUBY
+
+      assert_entry("bar", Entry::Accessor, "/fake/path/foo.rb:2-15:2-18")
+      assert_equal("Hello there", @index["bar"].first.comments.join("\n"))
+      assert_entry("other", Entry::Accessor, "/fake/path/foo.rb:2-21:2-26")
+      assert_equal("Hello there", @index["other"].first.comments.join("\n"))
+      assert_entry("baz=", Entry::Accessor, "/fake/path/foo.rb:3-15:3-18")
+      assert_entry("qux", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
+      assert_entry("qux=", Entry::Accessor, "/fake/path/foo.rb:4-17:4-20")
+    end
+
+    def test_ignores_attributes_invoked_on_constant
+      index(<<~RUBY)
+        class Foo
+        end
+
+        Foo.attr_reader :bar
+      RUBY
+
+      assert_no_entry("bar")
+    end
   end
 end

data/lib/ruby_lsp/addon.rb

@@ -41,8 +41,8 @@ module RubyLsp
       end
 
       # Discovers and loads all addons. Returns the list of activated addons
-      sig { returns(T::Array[Addon]) }
-      def load_addons
+      sig { params(message_queue: Thread::Queue).returns(T::Array[Addon]) }
+      def load_addons(message_queue)
         # Require all addons entry points, which should be placed under
         # `some_gem/lib/ruby_lsp/your_gem_name/addon.rb`
         Gem.find_files("ruby_lsp/**/addon.rb").each do |addon|
@@ -55,7 +55,7 @@ module RubyLsp
         # Activate each one of the discovered addons. If any problems occur in the addons, we don't want to
         # fail to boot the server
         addons.each do |addon|
-          addon.activate
+          addon.activate(message_queue)
           nil
         rescue => e
           addon.add_error(e)
@@ -94,8 +94,8 @@ module RubyLsp
 
     # Each addon should implement `MyAddon#activate` and use to perform any sort of initialization, such as
     # reading information into memory or even spawning a separate process
-    sig { abstract.void }
-    def activate; end
+    sig { abstract.params(message_queue: Thread::Queue).void }
+    def activate(message_queue); end
 
     # Each addon should implement `MyAddon#deactivate` and use to perform any clean up, like shutting down a
     # child process
@@ -111,10 +111,9 @@ module RubyLsp
       overridable.params(
         uri: URI::Generic,
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
     end
-    def create_code_lens_listener(uri, dispatcher, message_queue); end
+    def create_code_lens_listener(uri, dispatcher); end
 
     # Creates a new Hover listener. This method is invoked on every Hover request
     sig do
@@ -122,19 +121,17 @@ module RubyLsp
         nesting: T::Array[String],
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
     end
-    def create_hover_listener(nesting, index, dispatcher, message_queue); end
+    def create_hover_listener(nesting, index, dispatcher); end
 
     # Creates a new DocumentSymbol listener. This method is invoked on every DocumentSymbol request
     sig do
       overridable.params(
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T::Array[Interface::DocumentSymbol]]))
     end
-    def create_document_symbol_listener(dispatcher, message_queue); end
+    def create_document_symbol_listener(dispatcher); end
 
     # Creates a new Definition listener. This method is invoked on every Definition request
     sig do
@@ -143,9 +140,8 @@ module RubyLsp
         nesting: T::Array[String],
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
-        message_queue: Thread::Queue,
       ).returns(T.nilable(Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]))
     end
-    def create_definition_listener(uri, nesting, index, dispatcher, message_queue); end
+    def create_definition_listener(uri, nesting, index, dispatcher); end
   end
 end

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,12 @@ 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)
+        code_lens = Requests::CodeLens.new(uri, 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 +265,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 +291,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 +349,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 +379,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 +392,7 @@ module RubyLsp
       end_line = range.dig(:end, :line)
 
       dispatcher = Prism::Dispatcher.new
-      listener = Requests::InlayHints.new(start_line..end_line, dispatcher, @message_queue)
+      listener = Requests::InlayHints.new(start_line..end_line, dispatcher)
       dispatcher.visit(document.tree)
       listener.response
     end
@@ -443,6 +442,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 +461,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 +513,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 +578,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

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_lens.rb

@@ -47,16 +47,18 @@ 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 { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
+      def initialize(uri, 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])
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -82,12 +84,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 }
@@ -146,7 +152,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 +180,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 +196,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 +204,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
@@ -168,13 +171,16 @@ module RubyLsp
 
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
+        # We should use the content location as we only replace the content and not the delimiters of the string
+        loc = node.content_loc
+
         Interface::CompletionItem.new(
           label: label,
           text_edit: Interface::TextEdit.new(
-            range: range_from_node(node),
+            range: range_from_location(loc),
             new_text: label,
           ),
-          kind: Constant::CompletionItemKind::REFERENCE,
+          kind: Constant::CompletionItemKind::FILE,
         )
       end
 

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

@@ -39,9 +39,9 @@ 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 { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher).void }
+      def initialize(range, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -20,8 +20,8 @@ module RubyLsp
 
       END_REGEXES = T.let(
         [
-          /(if|unless|for|while|class|module|until|def|case).*/,
-          /.*\sdo/,
+          /\b(if|unless|for|while|class|module|until|def|case)\b.*/,
+          /.*\s\bdo\b/,
         ],
         T::Array[Regexp],
       )
@@ -139,7 +139,6 @@ module RubyLsp
       sig { params(spaces: String).void }
       def handle_comment_line(spaces)
         add_edit_with_text("##{spaces}")
-        move_cursor_to(@position[:line], @indentation + spaces.size + 1)
       end
 
       sig { params(text: String, position: Document::PositionShape).void }

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -107,20 +107,15 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig do
-        params(
-          dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
-          range: T.nilable(T::Range[Integer]),
-        ).void
-      end
-      def initialize(dispatcher, message_queue, range: nil)
-        super(dispatcher, message_queue)
+      sig { params(dispatcher: Prism::Dispatcher, range: T.nilable(T::Range[Integer])).void }
+      def initialize(dispatcher, range: nil)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
         @current_scope = T.let(ParameterScope.new, ParameterScope)
+        @inside_regex_capture = T.let(false, T::Boolean)
 
         dispatcher.register(
           self,
@@ -152,6 +147,8 @@ module RubyLsp
           :on_local_variable_or_write_node_enter,
           :on_local_variable_target_node_enter,
           :on_block_local_variable_node_enter,
+          :on_match_write_node_enter,
+          :on_match_write_node_leave,
         )
       end
 
@@ -165,14 +162,28 @@ module RubyLsp
         # We can't push a semantic token for [] and []= because the argument inside the brackets is a part of
         # the message_loc
         return if message.start_with?("[") && (message.end_with?("]") || message.end_with?("]="))
-
-        return process_regexp_locals(node) if message == "=~"
+        return if message == "=~"
         return if special_method?(message)
 
         type = Support::Sorbet.annotation?(node) ? :type : :method
         add_token(T.must(node.message_loc), type)
       end
 
+      sig { params(node: Prism::MatchWriteNode).void }
+      def on_match_write_node_enter(node)
+        call = node.call
+
+        if call.message == "=~"
+          @inside_regex_capture = true
+          process_regexp_locals(call)
+        end
+      end
+
+      sig { params(node: Prism::MatchWriteNode).void }
+      def on_match_write_node_leave(node)
+        @inside_regex_capture = true if node.call.message == "=~"
+      end
+
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
         return unless visible?(node, @range)
@@ -359,6 +370,12 @@ module RubyLsp
 
       sig { params(node: Prism::LocalVariableTargetNode).void }
       def on_local_variable_target_node_enter(node)
+        # If we're inside a regex capture, Prism will add LocalVariableTarget nodes for each captured variable.
+        # Unfortunately, if the regex contains a backslash, the location will be incorrect and we'll end up highlighting
+        # the entire regex as a local variable. We process these captures in process_regexp_locals instead and then
+        # prevent pushing local variable target tokens. See https://github.com/ruby/prism/issues/1912
+        return if @inside_regex_capture
+
         return unless visible?(node, @range)
 
         add_token(node.location, @current_scope.type_for(node.name))

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

@@ -34,15 +34,10 @@ module RubyLsp
 
         sig { override.params(uri: URI::Generic, document: Document).returns(T.nilable(String)) }
         def run(uri, document)
-          relative_path = Pathname.new(T.must(uri.to_standardized_path || uri.opaque))
-            .relative_path_from(T.must(WORKSPACE_URI.to_standardized_path))
-          return if @options.ignore_files.any? { |pattern| File.fnmatch(pattern, relative_path) }
+          path = uri.to_standardized_path
+          return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
 
-          SyntaxTree.format(
-            document.source,
-            @options.print_width,
-            options: @options.formatter_options,
-          )
+          SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
       end
     end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -75,6 +75,8 @@ module RubyLsp
           Constant::SymbolKind::CONSTANT
         when RubyIndexer::Entry::Method
           entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
+        when RubyIndexer::Entry::Accessor
+          Constant::SymbolKind::PROPERTY
         end
       end
     end

data/lib/ruby_lsp/store.rb

@@ -17,6 +17,9 @@ module RubyLsp
     sig { returns(T::Boolean) }
     attr_accessor :experimental_features
 
+    sig { returns(URI::Generic) }
+    attr_accessor :workspace_uri
+
     sig { void }
     def initialize
       @state = T.let({}, T::Hash[String, Document])
@@ -24,6 +27,7 @@ module RubyLsp
       @formatter = T.let("auto", String)
       @supports_progress = T.let(true, T::Boolean)
       @experimental_features = T.let(false, T::Boolean)
+      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
     end
 
     sig { params(uri: URI::Generic).returns(Document) }

data/lib/ruby_lsp/utils.rb

@@ -4,10 +4,6 @@
 module RubyLsp
   # Used to indicate that a request shouldn't return a response
   VOID = T.let(Object.new.freeze, Object)
-
-  # This freeze is not redundant since the interpolated string is mutable
-  WORKSPACE_URI = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
-
   BUNDLE_PATH = T.let(
     begin
       Bundler.bundle_path.to_s

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.12.4
+  version: 0.13.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-22 00:00:00.000000000 Z
+date: 2023-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -30,20 +30,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.1
+        version: 0.18.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.17.1
+        version: 0.18.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement