ruby-lsp 0.19.0 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1d89f4c5d5724a4b8c17002986c64d9f3ea2951282e4a35d96d50b0dd699ba9
-  data.tar.gz: f3513888e58fbde4a85d93a2ef58ae124e02c354729693ae5e928a66548cd058
+  metadata.gz: d900634d5328c8b4b5fcf799f807456bec3cdb94d6294c80fa9152bcf45aedde
+  data.tar.gz: b7661867d38331ec158312b10c7f530cbd58994ee94e8ff592f478e7e05efcb7
 SHA512:
-  metadata.gz: 57b44fec7c55b57408e042a9c40fe900c2445aa9fefa811223aa3154f5a4e1e8b1d0f11cf306548b13653f3a61877bcb8d01df7beeadb4766f2094b27786653b
-  data.tar.gz: cf769828221a3a1cb65e906b2b9c5c0c8fac8feee265e5f31b90fb96813f10a225798da1b3746165e11fd4591f7bd0620ab177233c2214d939986e22a1e3709b
+  metadata.gz: 8f7955f676bc5f231f990f04d8aea1a767165d4f2cac1e9514928014cd8a09eb68c60b4cd226a94b554dac88d77c2117ae3a3ea76bb66e68980974f1685d8970
+  data.tar.gz: 1b914d5607e5730139780cd1f172923db7878a7a0a4098daa1e17df8a1a7a2d8b6731b092baf7eeefc9f55605305e4d70d8cca8489f68a17bab532026c38e8b2

data/VERSION

@@ -1 +1 @@
-0.19.0
+0.19.1

data/exe/ruby-lsp-check

@@ -32,7 +32,7 @@ files.each_with_index do |file, index|
   })
 
   result = server.pop_response
-  errors[file] = result.message if result.is_a?(RubyLsp::Error)
+  errors[file] = result if result.is_a?(RubyLsp::Error)
 ensure
   server.process_message({ method: "textDocument/didClose", params: { textDocument: { uri: uri } } })
   server.pop_response

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

@@ -110,6 +110,10 @@ module RubyIndexer
         else
           ""
         end
+      rescue Errno::ENOENT
+        # If the file was deleted, but the entry hasn't been removed yet (could happen due to concurrency), then we do
+        # not want to fail. Just set the comments to an empty string
+        ""
       end
     end
 
@@ -525,6 +529,9 @@ module RubyIndexer
       end
     end
 
+    # Represents a global variable e.g.: $DEBUG
+    class GlobalVariable < Entry; end
+
     # Represents an instance variable e.g.: @a = 1
     class InstanceVariable < Entry
       sig { returns(T.nilable(Entry::Namespace)) }

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -677,11 +677,13 @@ module RubyIndexer
     sig do
       type_parameters(:T).params(
         path: String,
-        type: T::Class[T.all(T.type_parameter(:T), Entry)],
-      ).returns(T.nilable(T::Array[T.type_parameter(:T)]))
+        type: T.nilable(T::Class[T.all(T.type_parameter(:T), Entry)]),
+      ).returns(T.nilable(T.any(T::Array[Entry], T::Array[T.type_parameter(:T)])))
     end
-    def entries_for(path, type)
+    def entries_for(path, type = nil)
       entries = @files_to_entries[path]
+      return entries unless type
+
       entries&.grep(type)
     end
 

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -44,6 +44,8 @@ module RubyIndexer
       when RBS::AST::Declarations::Constant
         namespace_nesting = declaration.name.namespace.path.map(&:to_s)
         handle_constant(declaration, namespace_nesting, pathname.to_s)
+      when RBS::AST::Declarations::Global
+        handle_global_variable(declaration, pathname)
       else # rubocop:disable Style/EmptyElse
         # Other kinds not yet handled
       end
@@ -271,6 +273,23 @@ module RubyIndexer
       ))
     end
 
+    sig { params(declaration: RBS::AST::Declarations::Global, pathname: Pathname).void }
+    def handle_global_variable(declaration, pathname)
+      name = declaration.name.to_s
+      file_path = pathname.to_s
+      location = to_ruby_indexer_location(declaration.location)
+      comments = comments_to_string(declaration)
+      encoding = @index.configuration.encoding
+
+      @index.add(Entry::GlobalVariable.new(
+        name,
+        file_path,
+        location,
+        comments,
+        encoding,
+      ))
+    end
+
     sig { params(member: RBS::AST::Members::Alias, owner_entry: Entry::Namespace).void }
     def handle_signature_alias(member, owner_entry)
       file_path = member.location.buffer.name
@@ -294,6 +313,7 @@ module RubyIndexer
         RBS::AST::Declarations::Class,
         RBS::AST::Declarations::Module,
         RBS::AST::Declarations::Constant,
+        RBS::AST::Declarations::Global,
         RBS::AST::Members::MethodDefinition,
         RBS::AST::Members::Alias,
       )).returns(T.nilable(String))

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

@@ -5,6 +5,38 @@ module RubyIndexer
   class ReferenceFinder
     extend T::Sig
 
+    class Target
+      extend T::Helpers
+
+      abstract!
+    end
+
+    class ConstTarget < Target
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :fully_qualified_name
+
+      sig { params(fully_qualified_name: String).void }
+      def initialize(fully_qualified_name)
+        super()
+        @fully_qualified_name = fully_qualified_name
+      end
+    end
+
+    class MethodTarget < Target
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :method_name
+
+      sig { params(method_name: String).void }
+      def initialize(method_name)
+        super()
+        @method_name = method_name
+      end
+    end
+
     class Reference
       extend T::Sig
 
@@ -14,26 +46,29 @@ module RubyIndexer
       sig { returns(Prism::Location) }
       attr_reader :location
 
-      sig { params(name: String, location: Prism::Location).void }
-      def initialize(name, location)
+      sig { returns(T::Boolean) }
+      attr_reader :declaration
+
+      sig { params(name: String, location: Prism::Location, declaration: T::Boolean).void }
+      def initialize(name, location, declaration:)
         @name = name
         @location = location
+        @declaration = declaration
       end
     end
 
-    sig { returns(T::Array[Reference]) }
-    attr_reader :references
-
     sig do
       params(
-        fully_qualified_name: String,
+        target: Target,
         index: RubyIndexer::Index,
         dispatcher: Prism::Dispatcher,
+        include_declarations: T::Boolean,
       ).void
     end
-    def initialize(fully_qualified_name, index, dispatcher)
-      @fully_qualified_name = fully_qualified_name
+    def initialize(target, index, dispatcher, include_declarations: true)
+      @target = target
       @index = index
+      @include_declarations = include_declarations
       @stack = T.let([], T::Array[String])
       @references = T.let([], T::Array[Reference])
 
@@ -59,17 +94,25 @@ module RubyIndexer
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
         :on_constant_operator_write_node_enter,
+        :on_call_node_enter,
       )
     end
 
+    sig { returns(T::Array[Reference]) }
+    def references
+      return @references if @include_declarations
+
+      @references.reject(&:declaration)
+    end
+
     sig { params(node: Prism::ClassNode).void }
     def on_class_node_enter(node)
       constant_path = node.constant_path
       name = constant_path.slice
       nesting = actual_nesting(name)
 
-      if nesting.join("::") == @fully_qualified_name
-        @references << Reference.new(name, constant_path.location)
+      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
+        @references << Reference.new(name, constant_path.location, declaration: true)
       end
 
       @stack << name
@@ -86,8 +129,8 @@ module RubyIndexer
       name = constant_path.slice
       nesting = actual_nesting(name)
 
-      if nesting.join("::") == @fully_qualified_name
-        @references << Reference.new(name, constant_path.location)
+      if @target.is_a?(ConstTarget) && nesting.join("::") == @target.fully_qualified_name
+        @references << Reference.new(name, constant_path.location, declaration: true)
       end
 
       @stack << name
@@ -203,6 +246,10 @@ module RubyIndexer
 
     sig { params(node: Prism::DefNode).void }
     def on_def_node_enter(node)
+      if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
+        @references << Reference.new(name, node.name_loc, declaration: true)
+      end
+
       if node.receiver.is_a?(Prism::SelfNode)
         @stack << "<Class:#{@stack.last}>"
       end
@@ -215,6 +262,13 @@ module RubyIndexer
       end
     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
+        @references << Reference.new(name, T.must(node.message_loc), declaration: false)
+      end
+    end
+
     private
 
     sig { params(name: String).returns(T::Array[String]) }
@@ -233,13 +287,21 @@ module RubyIndexer
 
     sig { params(name: String, location: Prism::Location).void }
     def collect_constant_references(name, location)
+      return unless @target.is_a?(ConstTarget)
+
       entries = @index.resolve(name, @stack)
       return unless entries
 
+      previous_reference = @references.last
+
       entries.each do |entry|
-        next unless entry.name == @fully_qualified_name
+        next unless entry.name == @target.fully_qualified_name
+
+        # When processing a class/module declaration, we eagerly handle the constant reference. To avoid duplicates,
+        # when we find the constant node defining the namespace, then we have to check if it wasn't already added
+        next if previous_reference&.location == location
 
-        @references << Reference.new(name, location)
+        @references << Reference.new(name, location, declaration: false)
       end
     end
 

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -630,5 +630,17 @@ module RubyIndexer
         its namespace nesting, and the surrounding CallNode (e.g. a method call).
       COMMENTS
     end
+
+    def test_lazy_comment_fetching_does_not_fail_if_file_gets_deleted
+      indexable = IndexablePath.new("#{Dir.pwd}/lib", "lib/ruby_lsp/does_not_exist.rb")
+
+      @index.index_single(indexable, <<~RUBY, collect_comments: false)
+        class Foo
+        end
+      RUBY
+
+      entry = @index["Foo"].first
+      assert_empty(entry.comments)
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -1858,6 +1858,9 @@ module RubyIndexer
 
       entries = @index.entries_for("/fake/path/foo.rb", RubyIndexer::Entry::Namespace)
       assert_equal(["Foo", "Bar", "Bar::<Class:Bar>"], entries.map(&:name))
+
+      entries = @index.entries_for("/fake/path/foo.rb")
+      assert_equal(["Foo", "Bar", "my_def", "Bar::<Class:Bar>", "my_singleton_def"], entries.map(&:name))
     end
 
     def test_entries_for_returns_nil_if_no_matches

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -76,6 +76,20 @@ module RubyIndexer
       assert_operator(entry.location.end_column, :>, 0)
     end
 
+    def test_index_global_declaration
+      entries = @index["$DEBUG"]
+      refute_nil(entries)
+      assert_equal(1, entries.length)
+
+      entry = entries.first
+
+      assert_instance_of(Entry::GlobalVariable, entry)
+      assert_equal("$DEBUG", entry.name)
+      assert_match(%r{/gems/rbs-.*/core/global_variables.rbs}, entry.file_path)
+      assert_operator(entry.location.start_column, :<, entry.location.end_column)
+      assert_equal(entry.location.start_line, entry.location.end_line)
+    end
+
     def test_attaches_correct_owner_to_singleton_methods
       entries = @index["basename"]
       refute_nil(entries)

data/lib/ruby_indexer/test/reference_finder_test.rb

@@ -6,7 +6,7 @@ require "test_helper"
 module RubyIndexer
   class ReferenceFinderTest < Minitest::Test
     def test_finds_constant_references
-      refs = find_references("Foo::Bar", <<~RUBY)
+      refs = find_const_references("Foo::Bar", <<~RUBY)
         module Foo
           class Bar
           end
@@ -28,7 +28,7 @@ module RubyIndexer
     end
 
     def test_finds_constant_references_inside_singleton_contexts
-      refs = find_references("Foo::<Class:Foo>::Bar", <<~RUBY)
+      refs = find_const_references("Foo::<Class:Foo>::Bar", <<~RUBY)
         class Foo
           class << self
             class Bar
@@ -47,7 +47,7 @@ module RubyIndexer
     end
 
     def test_finds_top_level_constant_references
-      refs = find_references("Bar", <<~RUBY)
+      refs = find_const_references("Bar", <<~RUBY)
         class Bar
         end
 
@@ -70,17 +70,173 @@ module RubyIndexer
       assert_equal(8, refs[2].location.start_line)
     end
 
+    def test_finds_method_references
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def baz
+            foo
+          end
+        end
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(6, refs[1].location.start_line)
+    end
+
+    def test_does_not_mismatch_on_readers_and_writers
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def foo=(value)
+          end
+
+          def baz
+            self.foo = 1
+            self.foo
+          end
+        end
+      RUBY
+
+      # We want to match `foo` but not `foo=`
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(10, refs[1].location.start_line)
+    end
+
+    def test_matches_writers
+      refs = find_method_references("foo=", <<~RUBY)
+        class Bar
+          def foo
+          end
+
+          def foo=(value)
+          end
+
+          def baz
+            self.foo = 1
+            self.foo
+          end
+        end
+      RUBY
+
+      # We want to match `foo=` but not `foo`
+      assert_equal(2, refs.size)
+
+      assert_equal("foo=", refs[0].name)
+      assert_equal(5, refs[0].location.start_line)
+
+      assert_equal("foo=", refs[1].name)
+      assert_equal(9, refs[1].location.start_line)
+    end
+
+    def test_find_inherited_methods
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          def foo
+          end
+        end
+
+        class Baz < Bar
+          super.foo
+        end
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(7, refs[1].location.start_line)
+    end
+
+    def test_finds_methods_created_in_mixins
+      refs = find_method_references("foo", <<~RUBY)
+        module Mixin
+          def foo
+          end
+        end
+
+        class Bar
+          include Mixin
+        end
+
+        Bar.foo
+      RUBY
+
+      assert_equal(2, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(2, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(10, refs[1].location.start_line)
+    end
+
+    def test_finds_singleton_methods
+      # The current implementation matches on both `Bar.foo` and `Bar#foo` even though they are different
+
+      refs = find_method_references("foo", <<~RUBY)
+        class Bar
+          class << self
+            def foo
+            end
+          end
+
+          def foo
+          end
+        end
+
+        Bar.foo
+      RUBY
+
+      assert_equal(3, refs.size)
+
+      assert_equal("foo", refs[0].name)
+      assert_equal(3, refs[0].location.start_line)
+
+      assert_equal("foo", refs[1].name)
+      assert_equal(7, refs[1].location.start_line)
+
+      assert_equal("foo", refs[2].name)
+      assert_equal(11, refs[2].location.start_line)
+    end
+
     private
 
-    def find_references(fully_qualified_name, source)
+    def find_const_references(const_name, source)
+      target = ReferenceFinder::ConstTarget.new(const_name)
+      find_references(target, source)
+    end
+
+    def find_method_references(method_name, source)
+      target = ReferenceFinder::MethodTarget.new(method_name)
+      find_references(target, source)
+    end
+
+    def find_references(target, source)
       file_path = "/fake.rb"
       index = Index.new
       index.index_single(IndexablePath.new(nil, file_path), source)
       parse_result = Prism.parse(source)
       dispatcher = Prism::Dispatcher.new
-      finder = ReferenceFinder.new(fully_qualified_name, index, dispatcher)
+      finder = ReferenceFinder.new(target, index, dispatcher)
       dispatcher.visit(parse_result.value)
-      finder.references.uniq(&:location)
+      finder.references
     end
   end
 end

data/lib/ruby_lsp/erb_document.rb

@@ -50,7 +50,12 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
-      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+      RubyDocument.locate(
+        @parse_result.value,
+        create_scanner.find_char_position(position),
+        node_types: node_types,
+        encoding: @encoding,
+      )
     end
 
     sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }

data/lib/ruby_lsp/internal.rb

@@ -75,10 +75,12 @@ require "ruby_lsp/requests/hover"
 require "ruby_lsp/requests/inlay_hints"
 require "ruby_lsp/requests/on_type_formatting"
 require "ruby_lsp/requests/prepare_type_hierarchy"
+require "ruby_lsp/requests/range_formatting"
+require "ruby_lsp/requests/references"
+require "ruby_lsp/requests/rename"
 require "ruby_lsp/requests/selection_ranges"
 require "ruby_lsp/requests/semantic_highlighting"
 require "ruby_lsp/requests/show_syntax_tree"
 require "ruby_lsp/requests/signature_help"
 require "ruby_lsp/requests/type_hierarchy_supertypes"
 require "ruby_lsp/requests/workspace_symbol"
-require "ruby_lsp/requests/rename"

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -23,10 +23,11 @@ module RubyLsp
         end
       end
 
-      sig { params(document: RubyDocument, code_action: T::Hash[Symbol, T.untyped]).void }
-      def initialize(document, code_action)
+      sig { params(document: RubyDocument, global_state: GlobalState, code_action: T::Hash[Symbol, T.untyped]).void }
+      def initialize(document, global_state, code_action)
         super()
         @document = document
+        @global_state = global_state
         @code_action = code_action
       end
 
@@ -191,7 +192,12 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
-        node_context = RubyDocument.locate(@document.parse_result.value, start_index, node_types: [Prism::DefNode])
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          start_index,
+          node_types: [Prism::DefNode],
+          encoding: @global_state.encoding,
+        )
         closest_node = node_context.node
         return Error::InvalidTargetRange unless closest_node
 

data/lib/ruby_lsp/requests/completion.rb

@@ -57,6 +57,7 @@ module RubyLsp
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
           ],
+          encoding: global_state.encoding,
         )
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,

data/lib/ruby_lsp/requests/definition.rb

@@ -57,6 +57,7 @@ module RubyLsp
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
           ],
+          encoding: global_state.encoding,
         )
 
         target = node_context.node

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -28,7 +28,7 @@ module RubyLsp
         char_position = document.create_scanner.find_char_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
-        node_context = RubyDocument.locate(document.parse_result.value, char_position)
+        node_context = RubyDocument.locate(document.parse_result.value, char_position, encoding: global_state.encoding)
 
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,

data/lib/ruby_lsp/requests/hover.rb

@@ -41,6 +41,7 @@ module RubyLsp
           document.parse_result.value,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
+          encoding: global_state.encoding,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/range_formatting.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The [range formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_rangeFormatting)
+    # is used to format a selection or to format on paste.
+    class RangeFormatting < Request
+      extend T::Sig
+
+      sig { params(global_state: GlobalState, document: RubyDocument, params: T::Hash[Symbol, T.untyped]).void }
+      def initialize(global_state, document, params)
+        super()
+        @document = document
+        @uri = T.let(document.uri, URI::Generic)
+        @params = params
+        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
+      end
+
+      sig { override.returns(T.nilable(T::Array[Interface::TextEdit])) }
+      def perform
+        return unless @active_formatter
+        return if @document.syntax_error?
+
+        target = @document.locate_first_within_range(@params[:range])
+        return unless target
+
+        location = target.location
+
+        formatted_text = @active_formatter.run_range_formatting(
+          @uri,
+          target.slice,
+          location.start_column / 2,
+        )
+        return unless formatted_text
+
+        [
+          Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
+                line: location.start_line - 1,
+                character: location.start_code_units_column(@document.encoding),
+              ),
+              end: Interface::Position.new(
+                line: location.end_line - 1,
+                character: location.end_code_units_column(@document.encoding),
+              ),
+            ),
+            new_text: formatted_text.strip,
+          ),
+        ]
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/references.rb

@@ -0,0 +1,146 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [references](https://microsoft.github.io/language-server-protocol/specification#textDocument_references)
+    # request finds all references for the selected symbol.
+    class References < Request
+      extend T::Sig
+      include Support::Common
+
+      sig do
+        params(
+          global_state: GlobalState,
+          store: Store,
+          document: T.any(RubyDocument, ERBDocument),
+          params: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(global_state, store, document, params)
+        super()
+        @global_state = global_state
+        @store = store
+        @document = document
+        @params = params
+        @locations = T.let([], T::Array[Interface::Location])
+      end
+
+      sig { override.returns(T::Array[Interface::Location]) }
+      def perform
+        position = @params[:position]
+        char_position = @document.create_scanner.find_char_position(position)
+
+        node_context = RubyDocument.locate(
+          @document.parse_result.value,
+          char_position,
+          node_types: [
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ],
+          encoding: @global_state.encoding,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return @locations if !target || target.is_a?(Prism::ProgramNode)
+
+        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          target = determine_target(
+            target,
+            parent,
+            position,
+          )
+        end
+
+        target = T.cast(
+          target,
+          T.any(
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ),
+        )
+
+        reference_target = create_reference_target(target, node_context)
+        return @locations unless reference_target
+
+        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
+          uri = URI::Generic.from_path(path: path)
+          # If the document is being managed by the client, then we should use whatever is present in the store instead
+          # of reading from disk
+          next if @store.key?(uri)
+
+          parse_result = Prism.parse_file(path)
+          collect_references(reference_target, parse_result, uri)
+        end
+
+        @store.each do |_uri, document|
+          collect_references(reference_target, document.parse_result, document.uri)
+        end
+
+        @locations
+      end
+
+      private
+
+      sig do
+        params(
+          target_node: T.any(
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::ConstantPathTargetNode,
+            Prism::CallNode,
+            Prism::DefNode,
+          ),
+          node_context: NodeContext,
+        ).returns(T.nilable(RubyIndexer::ReferenceFinder::Target))
+      end
+      def create_reference_target(target_node, node_context)
+        case target_node
+        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+          name = constant_name(target_node)
+          return unless name
+
+          entries = @global_state.index.resolve(name, node_context.nesting)
+          return unless entries
+
+          fully_qualified_name = T.must(entries.first).name
+          RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        when Prism::CallNode, Prism::DefNode
+          RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
+        end
+      end
+
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          parse_result: Prism::ParseResult,
+          uri: URI::Generic,
+        ).void
+      end
+      def collect_references(target, parse_result, uri)
+        dispatcher = Prism::Dispatcher.new
+        finder = RubyIndexer::ReferenceFinder.new(
+          target,
+          @global_state.index,
+          dispatcher,
+          include_declarations: @params.dig(:context, :includeDeclaration) || true,
+        )
+        dispatcher.visit(parse_result.value)
+
+        finder.references.each do |reference|
+          @locations << Interface::Location.new(
+            uri: uri.to_s,
+            range: range_from_location(reference.location),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/rename.rb

@@ -37,6 +37,7 @@ module RubyLsp
           @document.parse_result.value,
           char_position,
           node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
+          encoding: @global_state.encoding,
         )
         target = node_context.node
         parent = node_context.parent
@@ -66,7 +67,8 @@ module RubyLsp
         end
 
         fully_qualified_name = T.must(entries.first).name
-        changes = collect_text_edits(fully_qualified_name, name)
+        reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        changes = collect_text_edits(reference_target, name)
 
         # If the client doesn't support resource operations, such as renaming files, then we can only return the basic
         # text changes
@@ -127,8 +129,13 @@ module RubyLsp
         end
       end
 
-      sig { params(fully_qualified_name: String, name: String).returns(T::Hash[String, T::Array[Interface::TextEdit]]) }
-      def collect_text_edits(fully_qualified_name, name)
+      sig do
+        params(
+          target: RubyIndexer::ReferenceFinder::Target,
+          name: String,
+        ).returns(T::Hash[String, T::Array[Interface::TextEdit]])
+      end
+      def collect_text_edits(target, name)
         changes = {}
 
         Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
@@ -138,12 +145,12 @@ module RubyLsp
           next if @store.key?(uri)
 
           parse_result = Prism.parse_file(path)
-          edits = collect_changes(fully_qualified_name, parse_result, name, uri)
+          edits = collect_changes(target, parse_result, name, uri)
           changes[uri.to_s] = edits unless edits.empty?
         end
 
         @store.each do |uri, document|
-          edits = collect_changes(fully_qualified_name, document.parse_result, name, document.uri)
+          edits = collect_changes(target, document.parse_result, name, document.uri)
           changes[uri] = edits unless edits.empty?
         end
 
@@ -152,18 +159,18 @@ module RubyLsp
 
       sig do
         params(
-          fully_qualified_name: String,
+          target: RubyIndexer::ReferenceFinder::Target,
           parse_result: Prism::ParseResult,
           name: String,
           uri: URI::Generic,
         ).returns(T::Array[Interface::TextEdit])
       end
-      def collect_changes(fully_qualified_name, parse_result, name, uri)
+      def collect_changes(target, parse_result, name, uri)
         dispatcher = Prism::Dispatcher.new
-        finder = RubyIndexer::ReferenceFinder.new(fully_qualified_name, @global_state.index, dispatcher)
+        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher)
         dispatcher.visit(parse_result.value)
 
-        finder.references.uniq(&:location).map do |reference|
+        finder.references.map do |reference|
           adjust_reference_for_edit(name, reference)
         end
       end

data/lib/ruby_lsp/requests/signature_help.rb

@@ -39,7 +39,12 @@ module RubyLsp
         char_position = document.create_scanner.find_char_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
-        node_context = RubyDocument.locate(document.parse_result.value, char_position, node_types: [Prism::CallNode])
+        node_context = RubyDocument.locate(
+          document.parse_result.value,
+          char_position,
+          node_types: [Prism::CallNode],
+          encoding: global_state.encoding,
+        )
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 

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

@@ -13,6 +13,9 @@ module RubyLsp
         sig { abstract.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
         def run_formatting(uri, document); end
 
+        sig { abstract.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        def run_range_formatting(uri, source, base_indentation); end
+
         sig do
           abstract.params(
             uri: URI::Generic,

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

@@ -28,6 +28,12 @@ module RubyLsp
           @format_runner.formatted_source
         end
 
+        # RuboCop does not support range formatting
+        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        def run_range_formatting(uri, source, base_indentation)
+          nil
+        end
+
         sig do
           override.params(
             uri: URI::Generic,

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

@@ -37,6 +37,14 @@ module RubyLsp
           SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
 
+        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        def run_range_formatting(uri, source, base_indentation)
+          path = uri.to_standardized_path
+          return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
+
+          SyntaxTree.format(source, @options.print_width, base_indentation, options: @options.formatter_options)
+        end
+
         sig do
           override.params(
             uri: URI::Generic,

data/lib/ruby_lsp/ruby_document.rb

@@ -26,9 +26,10 @@ module RubyLsp
           node: Prism::Node,
           char_position: Integer,
           node_types: T::Array[T.class_of(Prism::Node)],
+          encoding: Encoding,
         ).returns(NodeContext)
       end
-      def locate(node, char_position, node_types: [])
+      def locate(node, char_position, node_types: [], encoding: Encoding::UTF_8)
         queue = T.let(node.child_nodes.compact, T::Array[T.nilable(Prism::Node)])
         closest = node
         parent = T.let(nil, T.nilable(Prism::Node))
@@ -61,16 +62,21 @@ module RubyLsp
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
-          next unless (loc.start_offset...loc.end_offset).cover?(char_position)
+          loc_start_offset = loc.start_code_units_offset(encoding)
+          loc_end_offset = loc.end_code_units_offset(encoding)
+          next unless (loc_start_offset...loc_end_offset).cover?(char_position)
 
           # If the node's start character is already past the position, then we should've found the closest node
           # already
-          break if char_position < loc.start_offset
+          break if char_position < loc_start_offset
 
           # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level
           # and need to pop the stack
           previous_level = nesting_nodes.last
-          nesting_nodes.pop if previous_level && loc.start_offset > previous_level.location.end_offset
+          if previous_level &&
+              (loc_start_offset > previous_level.location.end_code_units_offset(encoding))
+            nesting_nodes.pop
+          end
 
           # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of
           # the target when it is a constant
@@ -83,8 +89,10 @@ module RubyLsp
           if candidate.is_a?(Prism::CallNode)
             arg_loc = candidate.arguments&.location
             blk_loc = candidate.block&.location
-            if (arg_loc && (arg_loc.start_offset...arg_loc.end_offset).cover?(char_position)) ||
-                (blk_loc && (blk_loc.start_offset...blk_loc.end_offset).cover?(char_position))
+            if (arg_loc && (arg_loc.start_code_units_offset(encoding)...
+                            arg_loc.end_code_units_offset(encoding)).cover?(char_position)) ||
+                (blk_loc && (blk_loc.start_code_units_offset(encoding)...
+                            blk_loc.end_code_units_offset(encoding)).cover?(char_position))
               call_node = candidate
             end
           end
@@ -94,7 +102,9 @@ module RubyLsp
 
           # If the current node is narrower than or equal to the previous closest node, then it is more precise
           closest_loc = closest.location
-          if loc.end_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
+          closest_node_start_offset = closest_loc.start_code_units_offset(encoding)
+          closest_node_end_offset = closest_loc.end_code_units_offset(encoding)
+          if loc_end_offset - loc_start_offset <= closest_node_end_offset - closest_node_start_offset
             parent = closest
             closest = candidate
           end
@@ -201,7 +211,12 @@ module RubyLsp
       ).returns(NodeContext)
     end
     def locate_node(position, node_types: [])
-      RubyDocument.locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
+      RubyDocument.locate(
+        @parse_result.value,
+        create_scanner.find_char_position(position),
+        node_types: node_types,
+        encoding: @encoding,
+      )
     end
   end
 end

data/lib/ruby_lsp/server.rb

@@ -43,6 +43,8 @@ module RubyLsp
         text_document_semantic_tokens_range(message)
       when "textDocument/formatting"
         text_document_formatting(message)
+      when "textDocument/rangeFormatting"
+        text_document_range_formatting(message)
       when "textDocument/documentHighlight"
         text_document_document_highlight(message)
       when "textDocument/onTypeFormatting"
@@ -69,6 +71,8 @@ module RubyLsp
         text_document_prepare_type_hierarchy(message)
       when "textDocument/rename"
         text_document_rename(message)
+      when "textDocument/references"
+        text_document_references(message)
       when "typeHierarchy/supertypes"
         type_hierarchy_supertypes(message)
       when "typeHierarchy/subtypes"
@@ -87,7 +91,16 @@ module RubyLsp
             id: message[:id],
             response:
               Addon.addons.map do |addon|
-                { name: addon.name, errored: addon.error? }
+                version_method = addon.method(:version)
+
+                # If the add-on doesn't define a `version` method, we'd be calling the abstract method defined by
+                # Sorbet, which would raise an error.
+                # Therefore, we only call the method if it's defined by the add-on itself
+                if version_method.owner != Addon
+                  version = addon.version
+                end
+
+                { name: addon.name, version: version, errored: addon.error? }
               end,
           ),
         )
@@ -230,6 +243,8 @@ module RubyLsp
           signature_help_provider: signature_help_provider,
           type_hierarchy_provider: type_hierarchy_provider,
           rename_provider: !@global_state.has_type_checker,
+          references_provider: !@global_state.has_type_checker,
+          document_range_formatting_provider: true,
           experimental: {
             addon_detection: true,
           },
@@ -513,6 +528,34 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: request.perform))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_range_formatting(message)
+      # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
+      if @global_state.formatter == "none"
+        send_empty_response(message[:id])
+        return
+      end
+
+      params = message[:params]
+      uri = params.dig(:textDocument, :uri)
+      # 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
+      unless path.nil? || path.start_with?(@global_state.workspace_path)
+        send_empty_response(message[:id])
+        return
+      end
+
+      document = @store.get(uri)
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      response = Requests::RangeFormatting.new(@global_state, document, params).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def text_document_formatting(message)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
@@ -636,6 +679,24 @@ module RubyLsp
       send_message(Error.new(id: message[:id], code: Constant::ErrorCodes::REQUEST_FAILED, message: e.message))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_references(message)
+      params = message[:params]
+      document = @store.get(params.dig(:textDocument, :uri))
+
+      unless document.is_a?(RubyDocument)
+        send_empty_response(message[:id])
+        return
+      end
+
+      send_message(
+        Result.new(
+          id: message[:id],
+          response: Requests::References.new(@global_state, @store, document, params).perform,
+        ),
+      )
+    end
+
     sig { params(document: Document[T.untyped]).returns(RubyDocument::SorbetLevel) }
     def sorbet_level(document)
       return RubyDocument::SorbetLevel::Ignore unless @global_state.has_type_checker
@@ -711,7 +772,7 @@ module RubyLsp
         return
       end
 
-      result = Requests::CodeActionResolve.new(document, params).perform
+      result = Requests::CodeActionResolve.new(document, @global_state, params).perform
 
       case result
       when Requests::CodeActionResolve::Error::EmptySelection

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.19.1
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 2024-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -154,6 +154,8 @@ files:
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
 - lib/ruby_lsp/requests/prepare_type_hierarchy.rb
+- lib/ruby_lsp/requests/range_formatting.rb
+- lib/ruby_lsp/requests/references.rb
 - lib/ruby_lsp/requests/rename.rb
 - lib/ruby_lsp/requests/request.rb
 - lib/ruby_lsp/requests/selection_ranges.rb