ruby-lsp 0.22.1 → 0.23.10

data/lib/ruby_lsp/requests/code_actions.rb

@@ -12,6 +12,21 @@ module RubyLsp
       EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
       EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
       TOGGLE_BLOCK_STYLE_TITLE = "Refactor: Toggle block style"
+      CREATE_ATTRIBUTE_READER = "Create Attribute Reader"
+      CREATE_ATTRIBUTE_WRITER = "Create Attribute Writer"
+      CREATE_ATTRIBUTE_ACCESSOR = "Create Attribute Accessor"
+
+      INSTANCE_VARIABLE_NODES = T.let(
+        [
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableReadNode,
+          Prism::InstanceVariableTargetNode,
+          Prism::InstanceVariableWriteNode,
+        ],
+        T::Array[T.class_of(Prism::Node)],
+      )
 
       class << self
         extend T::Sig
@@ -19,7 +34,7 @@ module RubyLsp
         sig { returns(Interface::CodeActionRegistrationOptions) }
         def provider
           Interface::CodeActionRegistrationOptions.new(
-            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            document_selector: nil,
             resolve_provider: true,
           )
         end
@@ -66,9 +81,50 @@ module RubyLsp
             data: { range: @range, uri: @uri.to_s },
           )
         end
+        code_actions.concat(attribute_actions)
 
         code_actions
       end
+
+      private
+
+      sig { returns(T::Array[Interface::CodeAction]) }
+      def attribute_actions
+        return [] unless @document.is_a?(RubyDocument)
+
+        node = if @range.dig(:start) != @range.dig(:end)
+          @document.locate_first_within_range(
+            @range,
+            node_types: INSTANCE_VARIABLE_NODES,
+          )
+        end
+
+        if node.nil?
+          node_context = @document.locate_node(
+            @range[:start],
+            node_types: CodeActions::INSTANCE_VARIABLE_NODES,
+          )
+          return [] unless INSTANCE_VARIABLE_NODES.include?(node_context.node.class)
+        end
+
+        [
+          Interface::CodeAction.new(
+            title: CREATE_ATTRIBUTE_READER,
+            kind: Constant::CodeActionKind::EMPTY,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+          Interface::CodeAction.new(
+            title: CREATE_ATTRIBUTE_WRITER,
+            kind: Constant::CodeActionKind::EMPTY,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+          Interface::CodeAction.new(
+            title: CREATE_ATTRIBUTE_ACCESSOR,
+            kind: Constant::CodeActionKind::EMPTY,
+            data: { range: @range, uri: @uri.to_s },
+          ),
+        ]
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/completion.rb

@@ -40,7 +40,8 @@ module RubyLsp
         @dispatcher = dispatcher
         # Completion always receives the position immediately after the character that was just typed. Here we adjust it
         # back by 1, so that we find the right node
-        char_position = document.create_scanner.find_char_position(params[:position]) - 1
+        char_position, _ = document.find_index_by_position(params[:position])
+        char_position -= 1
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
@@ -62,6 +63,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

@@ -29,7 +29,7 @@ module RubyLsp
         )
         @dispatcher = dispatcher
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
@@ -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/diagnostics.rb

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

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -25,7 +25,7 @@ module RubyLsp
       end
       def initialize(global_state, document, position, dispatcher)
         super()
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/folding_ranges.rb

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

data/lib/ruby_lsp/requests/formatting.rb

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

data/lib/ruby_lsp/requests/hover.rb

@@ -34,7 +34,7 @@ module RubyLsp
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -14,7 +14,7 @@ module RubyLsp
         sig { returns(Interface::DocumentOnTypeFormattingRegistrationOptions) }
         def provider
           Interface::DocumentOnTypeFormattingRegistrationOptions.new(
-            document_selector: [Interface::DocumentFilter.new(language: "ruby")],
+            document_selector: nil,
             first_trigger_character: "{",
             more_trigger_character: ["\n", "|", "d"],
           )
@@ -170,7 +170,7 @@ module RubyLsp
 
       sig { params(line: Integer, character: Integer).void }
       def move_cursor_to(line, character)
-        return unless @client_name.start_with?("Visual Studio Code")
+        return unless /Visual Studio Code|Cursor/.match?(@client_name)
 
         position = Interface::Position.new(
           line: line,

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.find_index_by_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/references.rb

@@ -30,7 +30,7 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::Location]) }
       def perform
         position = @params[:position]
-        char_position = @document.create_scanner.find_char_position(position)
+        char_position, _ = @document.find_index_by_position(position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,
@@ -39,6 +39,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
             Prism::CallNode,
             Prism::DefNode,
           ],
@@ -62,6 +68,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
             Prism::CallNode,
             Prism::DefNode,
           ),
@@ -97,6 +109,12 @@ module RubyLsp
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
             Prism::CallNode,
             Prism::DefNode,
           ),
@@ -106,7 +124,7 @@ module RubyLsp
       def create_reference_target(target_node, node_context)
         case target_node
         when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
-          name = constant_name(target_node)
+          name = RubyIndexer::Index.constant_name(target_node)
           return unless name
 
           entries = @global_state.index.resolve(name, node_context.nesting)
@@ -114,6 +132,14 @@ module RubyLsp
 
           fully_qualified_name = T.must(entries.first).name
           RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
+        when
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableReadNode,
+          Prism::InstanceVariableTargetNode,
+          Prism::InstanceVariableWriteNode
+          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s)
         when Prism::CallNode, Prism::DefNode
           RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
         end
@@ -132,6 +158,7 @@ module RubyLsp
           target,
           @global_state.index,
           dispatcher,
+          uri,
           include_declarations: @params.dig(:context, :includeDeclaration) || true,
         )
         dispatcher.visit(parse_result.value)

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,
@@ -31,7 +40,7 @@ module RubyLsp
 
       sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
       def perform
-        char_position = @document.create_scanner.find_char_position(@position)
+        char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
           @document.parse_result.value,
@@ -56,7 +65,7 @@ module RubyLsp
           T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
         )
 
-        name = constant_name(target)
+        name = RubyIndexer::Index.constant_name(target)
         return unless name
 
         entries = @global_state.index.resolve(name, node_context.nesting)
@@ -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 = 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
@@ -169,7 +179,7 @@ module RubyLsp
       end
       def collect_changes(target, parse_result, name, uri)
         dispatcher = Prism::Dispatcher.new
-        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher)
+        finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher, uri)
         dispatcher.visit(parse_result.value)
 
         finder.references.map do |reference|

data/lib/ruby_lsp/requests/semantic_highlighting.rb

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

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -31,10 +31,7 @@ module RubyLsp
       sig { returns(String) }
       def ast_for_range
         range = T.must(@range)
-
-        scanner = @document.create_scanner
-        start_char = scanner.find_char_position(range[:start])
-        end_char = scanner.find_char_position(range[:end])
+        start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup
         found_nodes = []

data/lib/ruby_lsp/requests/signature_help.rb

@@ -36,7 +36,7 @@ module RubyLsp
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 
-        char_position = document.create_scanner.find_char_position(position)
+        char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(

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
@@ -149,10 +145,7 @@ module RubyLsp
           ).returns(T.nilable(String))
         end
         def constant_name(node)
-          node.full_name
-        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
-               Prism::ConstantPathNode::MissingNodesInConstantPathError
-          nil
+          RubyIndexer::Index.constant_name(node)
         end
 
         sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }

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

@@ -31,7 +31,7 @@ module RubyLsp
 
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
-        sig { params(document: RubyDocument, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
+        sig { params(document: RubyDocument, offense: ::RuboCop::Cop::Offense, uri: URI::Generic).void }
         def initialize(document, offense, uri)
           @document = document
           @offense = offense
@@ -48,7 +48,7 @@ module RubyLsp
           code_actions
         end
 
-        sig { params(config: RuboCop::Config).returns(Interface::Diagnostic) }
+        sig { params(config: ::RuboCop::Config).returns(Interface::Diagnostic) }
         def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
@@ -90,7 +90,7 @@ module RubyLsp
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { params(config: RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        sig { params(config: ::RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
         def code_description(config)
           cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
           return unless cop

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

@@ -40,10 +40,10 @@ module RubyLsp
           For more details, run RuboCop on the command line.
         EOS
 
-        sig { params(rubocop_error: T.any(RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
+        sig { params(rubocop_error: T.any(::RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
         def initialize(rubocop_error)
           message = case rubocop_error
-          when RuboCop::ErrorWithAnalyzedFileLocation
+          when ::RuboCop::ErrorWithAnalyzedFileLocation
             format(MESSAGE, "for the #{rubocop_error.cop.name} cop")
           when StandardError
             format(MESSAGE, rubocop_error.message)
@@ -53,7 +53,7 @@ module RubyLsp
       end
 
       # :nodoc:
-      class RuboCopRunner < RuboCop::Runner
+      class RuboCopRunner < ::RuboCop::Runner
         extend T::Sig
 
         class ConfigurationError < StandardError; end
@@ -68,14 +68,14 @@ module RubyLsp
           T::Array[String],
         )
 
-        sig { returns(T::Array[RuboCop::Cop::Offense]) }
+        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"])
+          ::RuboCop::Options.new.parse(["--raise-cop-error"])
           DEFAULT_ARGS << "--raise-cop-error"
         rescue OptionParser::InvalidOption
           # older versions of RuboCop don't support this flag
@@ -85,7 +85,7 @@ module RubyLsp
         sig { params(args: String).void }
         def initialize(*args)
           @options = T.let({}, T::Hash[Symbol, T.untyped])
-          @offenses = T.let([], T::Array[RuboCop::Cop::Offense])
+          @offenses = T.let([], T::Array[::RuboCop::Cop::Offense])
           @errors = T.let([], T::Array[String])
           @warnings = T.let([], T::Array[String])
 
@@ -113,9 +113,9 @@ module RubyLsp
           # RuboCop rescues interrupts and then sets the `@aborting` variable to true. We don't want them to be rescued,
           # so here we re-raise in case RuboCop received an interrupt.
           raise Interrupt if aborting?
-        rescue RuboCop::Runner::InfiniteCorrectionLoop => error
+        rescue ::RuboCop::Runner::InfiniteCorrectionLoop => error
           raise Formatting::Error, error.message
-        rescue RuboCop::ValidationError => error
+        rescue ::RuboCop::ValidationError => error
           raise ConfigurationError, error.message
         rescue StandardError => error
           raise InternalRuboCopError, error
@@ -129,25 +129,25 @@ module RubyLsp
         class << self
           extend T::Sig
 
-          sig { params(cop_name: String).returns(T.nilable(T.class_of(RuboCop::Cop::Base))) }
+          sig { params(cop_name: String).returns(T.nilable(T.class_of(::RuboCop::Cop::Base))) }
           def find_cop_by_name(cop_name)
             cop_registry[cop_name]&.first
           end
 
           private
 
-          sig { returns(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]) }
+          sig { returns(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]) }
           def cop_registry
             @cop_registry ||= T.let(
-              RuboCop::Cop::Registry.global.to_h,
-              T.nilable(T::Hash[String, [T.class_of(RuboCop::Cop::Base)]]),
+              ::RuboCop::Cop::Registry.global.to_h,
+              T.nilable(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]),
             )
           end
         end
 
         private
 
-        sig { params(_file: String, offenses: T::Array[RuboCop::Cop::Offense]).void }
+        sig { params(_file: String, offenses: T::Array[::RuboCop::Cop::Offense]).void }
         def file_finished(_file, offenses)
           @offenses = offenses
         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,10 +21,11 @@ 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 = uri.full_path
 
           # We only show symbols declared in the workspace
-          in_dependencies = !not_in_dependencies?(file_path)
+          in_dependencies = file_path && !not_in_dependencies?(file_path)
           next if in_dependencies
 
           # We should never show private symbols when searching the entire workspace
@@ -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),