ruby-lsp 0.19.0 → 0.20.0

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -239,10 +239,10 @@ module RubyLsp
         statements = node.statements
         return unless statements
 
-        body = statements.body
-        return if body.empty?
+        statement = statements.body.last
+        return unless statement
 
-        add_lines_range(node.location.start_line, body.last.location.end_line)
+        add_lines_range(node.location.start_line, statement.location.end_line)
       end
 
       sig { params(node: Prism::Node).void }

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
 
@@ -98,7 +99,13 @@ module RubyLsp
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
-          .locate(@document.parse_result.value, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
+          .locate(@document.parse_result.value,
+            start_index,
+            node_types: [
+              Prism::StatementsNode,
+              Prism::BlockNode,
+            ],
+            code_units_cache: @document.code_units_cache)
 
         closest_statements = node_context.node
         parent_statements = node_context.parent
@@ -191,7 +198,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],
+          code_units_cache: @document.code_units_cache,
+        )
         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,
           ],
+          code_units_cache: document.code_units_cache,
         )
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,

data/lib/ruby_lsp/requests/definition.rb

@@ -46,6 +46,7 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::BlockArgumentNode,
+            Prism::GlobalVariableReadNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,
@@ -57,6 +58,7 @@ module RubyLsp
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
           ],
+          code_units_cache: document.code_units_cache,
         )
 
         target = node_context.node

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -28,7 +28,11 @@ 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,
+          code_units_cache: document.code_units_cache,
+        )
 
         @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,
+          code_units_cache: document.code_units_cache,
         )
         target = node_context.node
         parent = node_context.parent

data/lib/ruby_lsp/requests/range_formatting.rb

@@ -0,0 +1,57 @@
+# 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
+
+        code_units_cache = @document.code_units_cache
+
+        [
+          Interface::TextEdit.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
+                line: location.start_line - 1,
+                character: location.cached_start_code_units_column(code_units_cache),
+              ),
+              end: Interface::Position.new(
+                line: location.end_line - 1,
+                character: location.cached_end_code_units_column(code_units_cache),
+              ),
+            ),
+            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,
+          ],
+          code_units_cache: @document.code_units_cache,
+        )
+        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],
+          code_units_cache: @document.code_units_cache,
         )
         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/semantic_highlighting.rb

@@ -101,7 +101,7 @@ module RubyLsp
         @range = range
         @result_id = T.let(SemanticHighlighting.next_result_id.to_s, String)
         @response_builder = T.let(
-          ResponseBuilders::SemanticHighlighting.new(global_state.encoding),
+          ResponseBuilders::SemanticHighlighting.new(document.code_units_cache),
           ResponseBuilders::SemanticHighlighting,
         )
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder)

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],
+          code_units_cache: document.code_units_cache,
+        )
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 

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

@@ -159,7 +159,7 @@ module RubyLsp
         def namespace_constant_name(node)
           path = node.constant_path
           case path
-          when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
+          when Prism::ConstantPathNode, Prism::ConstantReadNode
             constant_name(path)
           end
         end

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

@@ -47,12 +47,6 @@ module RubyLsp
 
         class ConfigurationError < StandardError; end
 
-        sig { returns(T::Array[RuboCop::Cop::Offense]) }
-        attr_reader :offenses
-
-        sig { returns(::RuboCop::Config) }
-        attr_reader :config_for_working_directory
-
         DEFAULT_ARGS = T.let(
           [
             "--stderr", # Print any output to stderr so that our stdout does not get polluted
@@ -63,6 +57,12 @@ module RubyLsp
           T::Array[String],
         )
 
+        sig { returns(T::Array[RuboCop::Cop::Offense]) }
+        attr_reader :offenses
+
+        sig { returns(::RuboCop::Config) }
+        attr_reader :config_for_working_directory
+
         begin
           RuboCop::Options.new.parse(["--raise-cop-error"])
           DEFAULT_ARGS << "--raise-cop-error"

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/response_builders/document_symbol.rb

@@ -4,6 +4,8 @@
 module RubyLsp
   module ResponseBuilders
     class DocumentSymbol < ResponseBuilder
+      extend T::Sig
+
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
       class SymbolHierarchyRoot
@@ -18,8 +20,6 @@ module RubyLsp
         end
       end
 
-      extend T::Sig
-
       sig { void }
       def initialize
         super

data/lib/ruby_lsp/response_builders/hover.rb

@@ -4,11 +4,11 @@
 module RubyLsp
   module ResponseBuilders
     class Hover < ResponseBuilder
-      ResponseType = type_member { { fixed: String } }
-
       extend T::Sig
       extend T::Generic
 
+      ResponseType = type_member { { fixed: String } }
+
       sig { void }
       def initialize
         super

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -6,6 +6,8 @@ module RubyLsp
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
+      extend T::Sig
+
       TOKEN_TYPES = T.let(
         {
           namespace: 0,
@@ -51,25 +53,29 @@ module RubyLsp
         T::Hash[Symbol, Integer],
       )
 
-      extend T::Sig
-
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
-      sig { params(encoding: Encoding).void }
-      def initialize(encoding)
+      sig do
+        params(code_units_cache: T.any(
+          T.proc.params(arg0: Integer).returns(Integer),
+          Prism::CodeUnitsCache,
+        )).void
+      end
+      def initialize(code_units_cache)
         super()
-        @encoding = encoding
+        @code_units_cache = code_units_cache
         @stack = T.let([], T::Array[SemanticToken])
       end
 
       sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
-        length = location.end_code_units_offset(@encoding) - location.start_code_units_offset(@encoding)
+        end_code_unit = location.cached_end_code_units_offset(@code_units_cache)
+        length = end_code_unit - location.cached_start_code_units_offset(@code_units_cache)
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
         @stack.push(
           SemanticToken.new(
             start_line: location.start_line,
-            start_code_unit_column: location.start_code_units_column(@encoding),
+            start_code_unit_column: location.cached_start_code_units_column(@code_units_cache),
             length: length,
             type: T.must(TOKEN_TYPES[type]),
             modifier: modifiers_indices,
@@ -83,7 +89,7 @@ module RubyLsp
         return false unless token
 
         token.start_line == location.start_line &&
-          token.start_code_unit_column == location.start_code_units_column(@encoding)
+          token.start_code_unit_column == location.cached_start_code_units_column(@code_units_cache)
       end
 
       sig { returns(T.nilable(SemanticToken)) }

data/lib/ruby_lsp/response_builders/signature_help.rb

@@ -4,10 +4,10 @@
 module RubyLsp
   module ResponseBuilders
     class SignatureHelp < ResponseBuilder
-      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
-
       extend T::Sig
 
+      ResponseType = type_member { { fixed: T.nilable(Interface::SignatureHelp) } }
+
       sig { void }
       def initialize
         super