ruby-lsp 0.22.0 → 0.23.0

data/lib/ruby_lsp/listeners/completion.rb

@@ -97,6 +97,12 @@ module RubyLsp
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
@@ -110,13 +116,14 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
+        range = range_from_location(node.location)
         candidates = @index.constant_completion_candidates(name, @node_context.nesting)
         candidates.each do |entries|
           complete_name = T.must(entries.first).name
           @response_builder << build_entry_completion(
             complete_name,
             name,
-            range_from_location(node.location),
+            range,
             entries,
             top_level?(complete_name),
           )
@@ -246,6 +253,36 @@ module RubyLsp
         handle_instance_variable_completion(node.name.to_s, node.location)
       end
 
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.location)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        handle_class_variable_completion(node.name.to_s, node.name_loc)
+      end
+
       private
 
       sig { params(name: String, range: Interface::Range).void }
@@ -326,6 +363,37 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String, location: Prism::Location).void }
+      def handle_class_variable_completion(name, location)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        range = range_from_location(location)
+
+        @index.class_variable_completion_candidates(name, type.name).each do |entry|
+          variable_name = entry.name
+
+          label_details = Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+          )
+
+          @response_builder << Interface::CompletionItem.new(
+            label: variable_name,
+            label_details: label_details,
+            text_edit: Interface::TextEdit.new(
+              range: range,
+              new_text: variable_name,
+            ),
+            kind: Constant::CompletionItemKind::FIELD,
+            data: {
+              owner_name: entry.owner&.name,
+            },
+          )
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
+      end
+
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
@@ -335,6 +403,7 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
+        range = range_from_location(location)
         @index.instance_variable_completion_candidates(name, type.name).each do |entry|
           variable_name = entry.name
 
@@ -346,7 +415,7 @@ module RubyLsp
             label: variable_name,
             label_details: label_details,
             text_edit: Interface::TextEdit.new(
-              range: range_from_location(location),
+              range: range,
               new_text: variable_name,
             ),
             kind: Constant::CompletionItemKind::FIELD,
@@ -368,9 +437,9 @@ module RubyLsp
 
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        matched_indexable_paths = @index.search_require_paths(path_node_to_complete.content)
+        matched_uris = @index.search_require_paths(path_node_to_complete.content)
 
-        matched_indexable_paths.map!(&:require_path).sort!.each do |path|
+        matched_uris.map!(&:require_path).sort!.each do |path|
           @response_builder << build_completion(T.must(path), path_node_to_complete)
         end
       end

data/lib/ruby_lsp/listeners/definition.rb

@@ -55,6 +55,12 @@ module RubyLsp
           :on_symbol_node_enter,
           :on_super_node_enter,
           :on_forwarding_super_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
@@ -196,6 +202,36 @@ module RubyLsp
         handle_super_node_definition
       end
 
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        handle_class_variable_definition(node.name.to_s)
+      end
+
       private
 
       sig { void }
@@ -223,7 +259,7 @@ module RubyLsp
           location = entry.location
 
           @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            uri: entry.uri.to_s,
             range: Interface::Range.new(
               start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
               end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
@@ -232,6 +268,24 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String).void }
+      def handle_class_variable_definition(name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_class_variable(name, type.name)
+        return unless entries
+
+        entries.each do |entry|
+          @response_builder << Interface::Location.new(
+            uri: entry.uri.to_s,
+            range: range_from_location(entry.location),
+          )
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
@@ -248,7 +302,7 @@ module RubyLsp
           location = entry.location
 
           @response_builder << Interface::Location.new(
-            uri: URI::Generic.from_path(path: entry.file_path).to_s,
+            uri: entry.uri.to_s,
             range: Interface::Range.new(
               start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
               end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
@@ -275,11 +329,11 @@ module RubyLsp
         return unless methods
 
         methods.each do |target_method|
-          file_path = target_method.file_path
-          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(file_path)
+          uri = target_method.uri
+          next if sorbet_level_true_or_higher?(@sorbet_level) && not_in_dependencies?(T.must(uri.full_path))
 
           @response_builder << Interface::LocationLink.new(
-            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_uri: uri.to_s,
             target_range: range_from_location(target_method.location),
             target_selection_range: range_from_location(target_method.name_location),
           )
@@ -290,20 +344,22 @@ module RubyLsp
       def handle_require_definition(node, message)
         case message
         when :require
-          entry = @index.search_require_paths(node.content).find do |indexable_path|
-            indexable_path.require_path == node.content
+          entry = @index.search_require_paths(node.content).find do |uri|
+            uri.require_path == node.content
           end
 
           if entry
             candidate = entry.full_path
 
-            @response_builder << Interface::Location.new(
-              uri: URI::Generic.from_path(path: candidate).to_s,
-              range: Interface::Range.new(
-                start: Interface::Position.new(line: 0, character: 0),
-                end: Interface::Position.new(line: 0, character: 0),
-              ),
-            )
+            if candidate
+              @response_builder << Interface::Location.new(
+                uri: URI::Generic.from_path(path: candidate).to_s,
+                range: Interface::Range.new(
+                  start: Interface::Position.new(line: 0, character: 0),
+                  end: Interface::Position.new(line: 0, character: 0),
+                ),
+              )
+            end
           end
         when :require_relative
           required_file = "#{node.content}.rb"
@@ -346,11 +402,11 @@ module RubyLsp
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. The only sigil where Sorbet cannot handle constants is typed
           # ignore
-          file_path = entry.file_path
-          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(file_path)
+          uri = entry.uri
+          next if @sorbet_level != RubyDocument::SorbetLevel::Ignore && not_in_dependencies?(T.must(uri.full_path))
 
           @response_builder << Interface::LocationLink.new(
-            target_uri: URI::Generic.from_path(path: file_path).to_s,
+            target_uri: uri.to_s,
             target_range: range_from_location(entry.location),
             target_selection_range: range_from_location(entry.name_location),
           )

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -41,6 +41,10 @@ module RubyLsp
           :on_module_node_enter,
           :on_module_node_leave,
           :on_instance_variable_write_node_enter,
+          :on_instance_variable_target_node_enter,
+          :on_instance_variable_operator_write_node_enter,
+          :on_instance_variable_or_write_node_enter,
+          :on_instance_variable_and_write_node_enter,
           :on_class_variable_write_node_enter,
           :on_singleton_class_node_enter,
           :on_singleton_class_node_leave,
@@ -249,21 +253,61 @@ module RubyLsp
         @response_builder.pop
       end
 
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::VARIABLE,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
       sig { params(node: Prism::InstanceVariableWriteNode).void }
       def on_instance_variable_write_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
+          kind: Constant::SymbolKind::FIELD,
           range_location: node.name_loc,
           selection_range_location: node.name_loc,
         )
       end
 
-      sig { params(node: Prism::ClassVariableWriteNode).void }
-      def on_class_variable_write_node_enter(node)
+      sig { params(node: Prism::InstanceVariableTargetNode).void }
+      def on_instance_variable_target_node_enter(node)
         create_document_symbol(
           name: node.name.to_s,
-          kind: Constant::SymbolKind::VARIABLE,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.location,
+          selection_range_location: node.location,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableOperatorWriteNode).void }
+      def on_instance_variable_operator_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableOrWriteNode).void }
+      def on_instance_variable_or_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
+          range_location: node.name_loc,
+          selection_range_location: node.name_loc,
+        )
+      end
+
+      sig { params(node: Prism::InstanceVariableAndWriteNode).void }
+      def on_instance_variable_and_write_node_enter(node)
+        create_document_symbol(
+          name: node.name.to_s,
+          kind: Constant::SymbolKind::FIELD,
           range_location: node.name_loc,
           selection_range_location: node.name_loc,
         )
@@ -296,7 +340,7 @@ module RubyLsp
         ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_location:, selection_range_location:)
-        name = "<blank>" if name.empty?
+        name = "<blank>" if name.strip.empty?
         symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: kind,

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -195,7 +195,7 @@ module RubyLsp
       def push_comment_ranges
         # Group comments that are on consecutive lines and then push ranges for each group that has at least 2 comments
         @comments.chunk_while do |this, other|
-          this.location.end_line + 1 == other.location.start_line
+          this.location.end_line + 1 == other.location.start_line && !this.trailing? && !other.trailing?
         end.each do |chunk|
           next if chunk.length == 1
 

data/lib/ruby_lsp/listeners/hover.rb

@@ -31,6 +31,12 @@ module RubyLsp
           Prism::SuperNode,
           Prism::ForwardingSuperNode,
           Prism::YieldNode,
+          Prism::ClassVariableAndWriteNode,
+          Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableOrWriteNode,
+          Prism::ClassVariableReadNode,
+          Prism::ClassVariableTargetNode,
+          Prism::ClassVariableWriteNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -85,6 +91,12 @@ module RubyLsp
           :on_string_node_enter,
           :on_interpolated_string_node_enter,
           :on_yield_node_enter,
+          :on_class_variable_and_write_node_enter,
+          :on_class_variable_operator_write_node_enter,
+          :on_class_variable_or_write_node_enter,
+          :on_class_variable_read_node_enter,
+          :on_class_variable_target_node_enter,
+          :on_class_variable_write_node_enter,
         )
       end
 
@@ -215,6 +227,36 @@ module RubyLsp
         handle_keyword_documentation(node.keyword)
       end
 
+      sig { params(node: Prism::ClassVariableAndWriteNode).void }
+      def on_class_variable_and_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+      def on_class_variable_operator_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableOrWriteNode).void }
+      def on_class_variable_or_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableTargetNode).void }
+      def on_class_variable_target_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableReadNode).void }
+      def on_class_variable_read_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
+      sig { params(node: Prism::ClassVariableWriteNode).void }
+      def on_class_variable_write_node_enter(node)
+        handle_class_variable_hover(node.name.to_s)
+      end
+
       private
 
       sig { params(node: T.any(Prism::InterpolatedStringNode, Prism::StringNode)).void }
@@ -317,6 +359,21 @@ module RubyLsp
         end
       end
 
+      sig { params(name: String).void }
+      def handle_class_variable_hover(name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_class_variable(name, type.name)
+        return unless entries
+
+        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
+      end
+
       sig { params(name: String, location: Prism::Location).void }
       def generate_hover(name, location)
         entries = @index.resolve(name, @node_context.nesting)

data/lib/ruby_lsp/requests/completion.rb

@@ -62,6 +62,12 @@ module RubyLsp
             Prism::InstanceVariableOrWriteNode,
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
+            Prism::ClassVariableAndWriteNode,
+            Prism::ClassVariableOperatorWriteNode,
+            Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode,
+            Prism::ClassVariableTargetNode,
+            Prism::ClassVariableWriteNode,
           ],
           code_units_cache: document.code_units_cache,
         )

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -49,7 +49,8 @@ module RubyLsp
         if owner_name
           entries = entries.select do |entry|
             (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable) ||
-            entry.is_a?(RubyIndexer::Entry::MethodAlias)) && entry.owner&.name == owner_name
+            entry.is_a?(RubyIndexer::Entry::MethodAlias) || entry.is_a?(RubyIndexer::Entry::ClassVariable)) &&
+              entry.owner&.name == owner_name
           end
         end
 

data/lib/ruby_lsp/requests/definition.rb

@@ -56,6 +56,12 @@ module RubyLsp
             Prism::StringNode,
             Prism::SuperNode,
             Prism::ForwardingSuperNode,
+            Prism::ClassVariableAndWriteNode,
+            Prism::ClassVariableOperatorWriteNode,
+            Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode,
+            Prism::ClassVariableTargetNode,
+            Prism::ClassVariableWriteNode,
           ],
           code_units_cache: document.code_units_cache,
         )

data/lib/ruby_lsp/requests/prepare_rename.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # The
+    # [prepare_rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareRename)
+    # # request checks the validity of a rename operation at a given location.
+    class PrepareRename < Request
+      extend T::Sig
+      include Support::Common
+
+      sig do
+        params(
+          document: RubyDocument,
+          position: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(document, position)
+        super()
+        @document = document
+        @position = T.let(position, T::Hash[Symbol, Integer])
+      end
+
+      sig { override.returns(T.nilable(Interface::Range)) }
+      def perform
+        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],
+          code_units_cache: @document.code_units_cache,
+        )
+        target = node_context.node
+        parent = node_context.parent
+        return 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
+
+        range_from_location(target.location)
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -66,7 +66,7 @@ module RubyLsp
           Interface::TypeHierarchyItem.new(
             name: first_entry.name,
             kind: kind_for_entry(first_entry),
-            uri: URI::Generic.from_path(path: first_entry.file_path).to_s,
+            uri: first_entry.uri.to_s,
             range: range,
             selection_range: range,
           ),

data/lib/ruby_lsp/requests/rename.rb

@@ -12,6 +12,15 @@ module RubyLsp
 
       class InvalidNameError < StandardError; end
 
+      class << self
+        extend T::Sig
+
+        sig { returns(Interface::RenameOptions) }
+        def provider
+          Interface::RenameOptions.new(prepare_provider: true)
+        end
+      end
+
       sig do
         params(
           global_state: GlobalState,
@@ -106,7 +115,9 @@ module RubyLsp
 
         T.must(@global_state.index[fully_qualified_name]).each do |entry|
           # Do not rename files that are not part of the workspace
-          next unless entry.file_path.start_with?(@global_state.workspace_path)
+          uri = entry.uri
+          file_path = T.must(uri.full_path)
+          next unless file_path.start_with?(@global_state.workspace_path)
 
           case entry
           when RubyIndexer::Entry::Class, RubyIndexer::Entry::Module, RubyIndexer::Entry::Constant,
@@ -117,13 +128,12 @@ module RubyLsp
             if "#{file_name}.rb" == entry.file_name
               new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
 
-              old_uri = URI::Generic.from_path(path: entry.file_path).to_s
               new_uri = URI::Generic.from_path(path: File.join(
-                File.dirname(entry.file_path),
+                File.dirname(file_path),
                 "#{new_file_name}.rb",
               )).to_s
 
-              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: old_uri, new_uri: new_uri)
+              document_changes << Interface::RenameFile.new(kind: "rename", old_uri: uri.to_s, new_uri: new_uri)
             end
           end
         end

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

@@ -93,11 +93,7 @@ module RubyLsp
             # based, which is why instead of the usual subtraction of 1 to line numbers, we are actually adding 1 to
             # columns. The format for VS Code file URIs is
             # `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
-            uri = URI::Generic.from_path(
-              path: entry.file_path,
-              fragment: "L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}",
-            )
-
+            uri = "#{entry.uri}#L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}"
             definitions << "[#{entry.file_name}](#{uri})"
             content << "\n\n#{entry.comments}" unless entry.comments.empty?
           end

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -65,7 +65,7 @@ module RubyLsp
         Interface::TypeHierarchyItem.new(
           name: entry.name,
           kind: kind_for_entry(entry),
-          uri: URI::Generic.from_path(path: entry.file_path).to_s,
+          uri: entry.uri.to_s,
           range: range_from_location(entry.location),
           selection_range: range_from_location(entry.name_location),
           detail: entry.file_name,

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -21,7 +21,8 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
-          file_path = entry.file_path
+          uri = entry.uri
+          file_path = T.must(uri.full_path)
 
           # We only show symbols declared in the workspace
           in_dependencies = !not_in_dependencies?(file_path)
@@ -43,7 +44,7 @@ module RubyLsp
             container_name: container.join("::"),
             kind: kind,
             location: Interface::Location.new(
-              uri: URI::Generic.from_path(path: file_path).to_s,
+              uri: uri.to_s,
               range:  Interface::Range.new(
                 start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column),
                 end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -5,7 +5,7 @@ def compose(raw_initialize)
   require_relative "../setup_bundler"
   require "json"
   require "uri"
-  require_relative "../../core_ext/uri"
+  require "ruby_indexer/lib/ruby_indexer/uri"
 
   initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
   workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)