ruby-lsp 0.7.6 → 0.8.1

data/lib/ruby_lsp/executor.rb

@@ -15,6 +15,7 @@ module RubyLsp
       @store = store
       @test_library = T.let(DependencyDetector.detected_test_library, String)
       @message_queue = message_queue
+      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
     end
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(Result) }
@@ -35,7 +36,7 @@ module RubyLsp
 
     sig { params(request: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
     def run(request)
-      uri = request.dig(:params, :textDocument, :uri)
+      uri = URI(request.dig(:params, :textDocument, :uri).to_s)
 
       case request[:method]
       when "initialize"
@@ -57,6 +58,14 @@ module RubyLsp
           warn(errored_extensions.map(&:backtraces).join("\n\n"))
         end
 
+        if @store.experimental_features
+          # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
+          # stuck indexing files
+          RubyIndexer.configuration.load_config
+          @index.index_all
+          end_progress("indexing-progress")
+        end
+
         check_formatter_is_available
 
         warn("Ruby LSP is ready")
@@ -70,7 +79,7 @@ module RubyLsp
       when "textDocument/didClose"
         @message_queue << Notification.new(
           message: "textDocument/publishDiagnostics",
-          params: Interface::PublishDiagnosticsParams.new(uri: uri, diagnostics: []),
+          params: Interface::PublishDiagnosticsParams.new(uri: uri.to_s, diagnostics: []),
         )
 
         text_document_did_close(uri)
@@ -169,30 +178,64 @@ module RubyLsp
         completion(uri, request.dig(:params, :position))
       when "textDocument/definition"
         definition(uri, request.dig(:params, :position))
+      when "workspace/didChangeWatchedFiles"
+        did_change_watched_files(request.dig(:params, :changes))
       when "rubyLsp/textDocument/showSyntaxTree"
         show_syntax_tree(uri, request.dig(:params, :range))
       end
     end
 
-    sig { params(uri: String, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
+    sig { params(changes: T::Array[{ uri: String, type: Integer }]).returns(Object) }
+    def did_change_watched_files(changes)
+      changes.each do |change|
+        # File change events include folders, but we're only interested in files
+        uri = URI(change[:uri])
+        file_path = uri.to_standardized_path
+        next if file_path.nil? || File.directory?(file_path)
+
+        case change[:type]
+        when Constant::FileChangeType::CREATED
+          @index.index_single(file_path)
+        when Constant::FileChangeType::CHANGED
+          @index.delete(file_path)
+          @index.index_single(file_path)
+        when Constant::FileChangeType::DELETED
+          @index.delete(file_path)
+        end
+      end
+
+      VOID
+    end
+
+    sig { params(uri: URI::Generic, range: T.nilable(Document::RangeShape)).returns({ ast: String }) }
     def show_syntax_tree(uri, range)
       { ast: Requests::ShowSyntaxTree.new(@store.get(uri), range).run }
     end
 
-    sig { params(uri: String, position: Document::PositionShape).returns(T.nilable(Interface::Location)) }
+    sig do
+      params(
+        uri: URI::Generic,
+        position: Document::PositionShape,
+      ).returns(T.nilable(T.any(T::Array[Interface::Location], Interface::Location)))
+    end
     def definition(uri, position)
       document = @store.get(uri)
       return if document.syntax_error?
 
-      target, _parent = document.locate_node(position, node_types: [SyntaxTree::Command])
+      target, parent, nesting = document.locate_node(
+        position,
+        node_types: [SyntaxTree::Command, SyntaxTree::Const, SyntaxTree::ConstPathRef],
+      )
+
+      target = parent if target.is_a?(SyntaxTree::Const) && parent.is_a?(SyntaxTree::ConstPathRef)
 
       emitter = EventEmitter.new
-      base_listener = Requests::Definition.new(uri, emitter, @message_queue)
+      base_listener = Requests::Definition.new(uri, nesting, @index, emitter, @message_queue)
       emitter.emit_for_target(target)
       base_listener.response
     end
 
-    sig { params(uri: String).returns(T::Array[Interface::FoldingRange]) }
+    sig { params(uri: URI::Generic).returns(T::Array[Interface::FoldingRange]) }
     def folding_range(uri)
       @store.cache_fetch(uri, "textDocument/foldingRange") do |document|
         Requests::FoldingRanges.new(document).run
@@ -201,7 +244,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         position: Document::PositionShape,
       ).returns(T.nilable(Interface::Hover))
     end
@@ -227,19 +270,19 @@ module RubyLsp
       hover.response
     end
 
-    sig { params(uri: String, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    sig { params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
     def text_document_did_change(uri, content_changes, version)
       @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
     end
 
-    sig { params(uri: String, text: String, version: Integer).returns(Object) }
+    sig { params(uri: URI::Generic, text: String, version: Integer).returns(Object) }
     def text_document_did_open(uri, text, version)
       @store.set(uri: uri, source: text, version: version)
       VOID
     end
 
-    sig { params(uri: String).returns(Object) }
+    sig { params(uri: URI::Generic).returns(Object) }
     def text_document_did_close(uri)
       @store.delete(uri)
       VOID
@@ -247,7 +290,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         positions: T::Array[Document::PositionShape],
       ).returns(T.nilable(T::Array[T.nilable(Requests::Support::SelectionRange)]))
     end
@@ -270,7 +313,7 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String).returns(T.nilable(T::Array[Interface::TextEdit])) }
+    sig { params(uri: URI::Generic).returns(T.nilable(T::Array[Interface::TextEdit])) }
     def formatting(uri)
       # If formatter is set to `auto` but no supported formatting gem is found, don't attempt to format
       return if @store.formatter == "none"
@@ -280,7 +323,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         position: Document::PositionShape,
         character: String,
       ).returns(T::Array[Interface::TextEdit])
@@ -291,7 +334,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         position: Document::PositionShape,
       ).returns(T.nilable(T::Array[Interface::DocumentHighlight]))
     end
@@ -306,7 +349,7 @@ module RubyLsp
       listener.response
     end
 
-    sig { params(uri: String, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
+    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(T.nilable(T::Array[Interface::InlayHint])) }
     def inlay_hint(uri, range)
       document = @store.get(uri)
       return if document.syntax_error?
@@ -322,7 +365,7 @@ module RubyLsp
 
     sig do
       params(
-        uri: String,
+        uri: URI::Generic,
         range: Document::RangeShape,
         context: T::Hash[Symbol, T.untyped],
       ).returns(T.nilable(T::Array[Interface::CodeAction]))
@@ -335,7 +378,7 @@ module RubyLsp
 
     sig { params(params: T::Hash[Symbol, T.untyped]).returns(Interface::CodeAction) }
     def code_action_resolve(params)
-      uri = params.dig(:data, :uri)
+      uri = URI(params.dig(:data, :uri))
       document = @store.get(uri)
       result = Requests::CodeActionResolve.new(document, params).run
 
@@ -363,7 +406,7 @@ module RubyLsp
       end
     end
 
-    sig { params(uri: String).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
+    sig { params(uri: URI::Generic).returns(T.nilable(Interface::FullDocumentDiagnosticReport)) }
     def diagnostic(uri)
       response = @store.cache_fetch(uri, "textDocument/diagnostic") do |document|
         Requests::Diagnostics.new(document).run
@@ -372,7 +415,7 @@ module RubyLsp
       Interface::FullDocumentDiagnosticReport.new(kind: "full", items: response.map(&:to_lsp_diagnostic)) if response
     end
 
-    sig { params(uri: String, range: Document::RangeShape).returns(Interface::SemanticTokens) }
+    sig { params(uri: URI::Generic, range: Document::RangeShape).returns(Interface::SemanticTokens) }
     def semantic_tokens_range(uri, range)
       document = @store.get(uri)
       start_line = range.dig(:start, :line)
@@ -390,7 +433,10 @@ module RubyLsp
     end
 
     sig do
-      params(uri: String, position: Document::PositionShape).returns(T.nilable(T::Array[Interface::CompletionItem]))
+      params(
+        uri: URI::Generic,
+        position: Document::PositionShape,
+      ).returns(T.nilable(T::Array[Interface::CompletionItem]))
     end
     def completion(uri, position)
       document = @store.get(uri)
@@ -433,6 +479,37 @@ module RubyLsp
       listener.response
     end
 
+    sig { params(id: String, title: String).void }
+    def begin_progress(id, title)
+      return unless @store.supports_progress
+
+      @message_queue << Request.new(
+        message: "window/workDoneProgress/create",
+        params: Interface::WorkDoneProgressCreateParams.new(token: id),
+      )
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressBegin.new(kind: "begin", title: title),
+        ),
+      )
+    end
+
+    sig { params(id: String).void }
+    def end_progress(id)
+      return unless @store.supports_progress
+
+      @message_queue << Notification.new(
+        message: "$/progress",
+        params: Interface::ProgressParams.new(
+          token: id,
+          value: Interface::WorkDoneProgressEnd.new(kind: "end"),
+        ),
+      )
+    end
+
     sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
     def initialize_request(options)
       @store.clear
@@ -446,6 +523,7 @@ module RubyLsp
         encodings.first
       end
 
+      @store.supports_progress = options.dig(:capabilities, :window, :workDoneProgress) || true
       formatter = options.dig(:initializationOptions, :formatter) || "auto"
       @store.formatter = if formatter == "auto"
         DependencyDetector.detected_formatter
@@ -454,9 +532,7 @@ module RubyLsp
       end
 
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
-
-      # Uncomment the line below and use the variable to gate features behind the experimental flag
-      # experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled)
+      @store.experimental_features = options.dig(:initializationOptions, :experimentalFeaturesEnabled) || false
 
       enabled_features = case configured_features
       when Array
@@ -538,6 +614,37 @@ module RubyLsp
         )
       end
 
+      if @store.experimental_features
+        # Dynamically registered capabilities
+        file_watching_caps = options.dig(:capabilities, :workspace, :didChangeWatchedFiles)
+
+        # Not every client supports dynamic registration or file watching
+        if file_watching_caps&.dig(:dynamicRegistration) && file_watching_caps&.dig(:relativePatternSupport)
+          @message_queue << Request.new(
+            message: "client/registerCapability",
+            params: Interface::RegistrationParams.new(
+              registrations: [
+                # Register watching Ruby files
+                Interface::Registration.new(
+                  id: "workspace/didChangeWatchedFiles",
+                  method: "workspace/didChangeWatchedFiles",
+                  register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                    watchers: [
+                      Interface::FileSystemWatcher.new(
+                        glob_pattern: "**/*.rb",
+                        kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE,
+                      ),
+                    ],
+                  ),
+                ),
+              ],
+            ),
+          )
+        end
+
+        begin_progress("indexing-progress", "Ruby LSP: indexing files")
+      end
+
       Interface::InitializeResult.new(
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(

data/lib/ruby_lsp/extension.rb

@@ -97,8 +97,32 @@ module RubyLsp
     sig { abstract.void }
     def activate; end
 
+    # Each extension should implement `MyExtension#deactivate` and use to perform any clean up, like shutting down a
+    # child process
+    sig { abstract.void }
+    def deactivate; end
+
     # Extensions should override the `name` method to return the extension name
     sig { abstract.returns(String) }
     def name; end
+
+    # Creates a new CodeLens listener. This method is invoked on every CodeLens request
+    sig do
+      overridable.params(
+        uri: URI::Generic,
+        emitter: EventEmitter,
+        message_queue: Thread::Queue,
+      ).returns(T.nilable(Listener[T::Array[Interface::CodeLens]]))
+    end
+    def create_code_lens_listener(uri, emitter, message_queue); end
+
+    # Creates a new Hover listener. This method is invoked on every Hover request
+    sig do
+      overridable.params(
+        emitter: EventEmitter,
+        message_queue: Thread::Queue,
+      ).returns(T.nilable(Listener[T.nilable(Interface::Hover)]))
+    end
+    def create_hover_listener(emitter, message_queue); end
   end
 end

data/lib/ruby_lsp/internal.rb

@@ -3,12 +3,16 @@
 
 require "sorbet-runtime"
 require "syntax_tree"
+require "yarp"
 require "language_server-protocol"
 require "benchmark"
 require "bundler"
 require "uri"
+require "cgi"
 
 require "ruby-lsp"
+require "ruby_indexer/ruby_indexer"
+require "core_ext/uri"
 require "ruby_lsp/utils"
 require "ruby_lsp/server"
 require "ruby_lsp/executor"

data/lib/ruby_lsp/listener.rb

@@ -18,25 +18,26 @@ module RubyLsp
     def initialize(emitter, message_queue)
       @emitter = emitter
       @message_queue = message_queue
-    end
-
-    class << self
-      extend T::Sig
-
-      sig { returns(T::Array[T.class_of(Listener)]) }
-      def listeners
-        @listeners ||= T.let([], T.nilable(T::Array[T.class_of(Listener)]))
-      end
-
-      sig { params(listener: T.class_of(Listener)).void }
-      def add_listener(listener)
-        listeners << listener
-      end
+      @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
     end
 
     # Override this method with an attr_reader that returns the response of your listener. The listener should
     # accumulate results in a @response variable and then provide the reader so that it is accessible
     sig { abstract.returns(ResponseType) }
     def response; end
+
+    # Merge responses from all external listeners into the base listener's response. We do this to return a single
+    # response to the editor including the results of all extensions
+    sig { void }
+    def merge_external_listeners_responses!
+      @external_listeners.each { |l| merge_response!(l) }
+    end
+
+    # Does nothing by default. Requests that accept extensions should override this method to define how to merge
+    # responses coming from external listeners
+    sig { overridable.params(other: Listener[T.untyped]).returns(T.self_type) }
+    def merge_response!(other)
+      self
+    end
   end
 end

data/lib/ruby_lsp/requests/code_actions.rb

@@ -29,7 +29,7 @@ module RubyLsp
       def initialize(document, range, context)
         super(document)
 
-        @uri = T.let(document.uri, String)
+        @uri = T.let(document.uri, URI::Generic)
         @range = range
         @context = context
       end
@@ -63,14 +63,14 @@ module RubyLsp
           )
       end
 
-      sig { params(range: Document::RangeShape, uri: String).returns(Interface::CodeAction) }
+      sig { params(range: Document::RangeShape, uri: URI::Generic).returns(Interface::CodeAction) }
       def refactor_code_action(range, uri)
         Interface::CodeAction.new(
           title: "Refactor: Extract Variable",
           kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
           data: {
             range: range,
-            uri: uri,
+            uri: uri.to_s,
           },
         )
       end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -31,15 +31,17 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
       def initialize(uri, emitter, message_queue, test_library)
         super(emitter, message_queue)
 
-        @uri = T.let(uri, String)
-        @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
+        @uri = T.let(uri, URI::Generic)
+        @external_listeners.concat(
+          Extension.extensions.filter_map { |ext| ext.create_code_lens_listener(uri, emitter, message_queue) },
+        )
         @test_library = T.let(test_library, String)
         @response = T.let([], ResponseType)
-        @path = T.let(T.must(URI(uri).path), String)
+        @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([["public", "public"]], T::Array[T::Array[T.nilable(String)]])
         @class_stack = T.let([], T::Array[String])
@@ -55,22 +57,6 @@ module RubyLsp
           :after_call,
           :on_vcall,
         )
-
-        register_external_listeners!
-      end
-
-      sig { void }
-      def register_external_listeners!
-        self.class.listeners.each do |l|
-          @external_listeners << T.unsafe(l).new(@uri, @emitter, @message_queue)
-        end
-      end
-
-      sig { void }
-      def merge_external_listeners_responses!
-        @external_listeners.each do |l|
-          merge_response!(l)
-        end
       end
 
       sig { params(node: SyntaxTree::ClassDeclaration).void }
@@ -120,7 +106,7 @@ module RubyLsp
         if ACCESS_MODIFIERS.include?(node_message) && node.arguments.parts.any?
           visibility, _ = @visibility_stack.pop
           @visibility_stack.push([node_message, visibility])
-        elsif @path.include?("Gemfile") && node_message.include?("gem") && node.arguments.parts.any?
+        elsif @path&.include?("Gemfile") && node_message.include?("gem") && node.arguments.parts.any?
           remote = resolve_gem_remote(node)
           return unless remote
 
@@ -163,7 +149,7 @@ module RubyLsp
         end
       end
 
-      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
         @response.concat(other.response)
         self
@@ -174,7 +160,7 @@ module RubyLsp
       sig { params(node: SyntaxTree::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library)
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@test_library) && @path
 
         arguments = [
           @path,
@@ -231,7 +217,7 @@ module RubyLsp
 
       sig { params(class_name: String, method_name: T.nilable(String)).returns(String) }
       def generate_test_command(class_name:, method_name: nil)
-        command = BASE_COMMAND + @path
+        command = BASE_COMMAND + T.must(@path)
 
         case @test_library
         when "minitest"

data/lib/ruby_lsp/requests/definition.rb

@@ -20,18 +20,41 @@ module RubyLsp
       extend T::Sig
       extend T::Generic
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Location) } }
+      ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
 
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(uri, emitter, message_queue)
+      HAS_TYPECHECKER = T.let(DependencyDetector.typechecker?, T::Boolean)
+
+      sig do
+        params(
+          uri: URI::Generic,
+          nesting: T::Array[String],
+          index: RubyIndexer::Index,
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(uri, nesting, index, emitter, message_queue)
         super(emitter, message_queue)
 
         @uri = uri
+        @nesting = nesting
+        @index = index
         @response = T.let(nil, ResponseType)
-        emitter.register(self, :on_command)
+        emitter.register(self, :on_command, :on_const, :on_const_path_ref)
+      end
+
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        name = full_constant_name(node)
+        find_in_index(name)
+      end
+
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        find_in_index(node.value)
       end
 
       sig { params(node: SyntaxTree::Command).void }
@@ -53,7 +76,7 @@ module RubyLsp
 
           if candidate
             @response = Interface::Location.new(
-              uri: "file://#{candidate}",
+              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),
@@ -61,13 +84,13 @@ module RubyLsp
             )
           end
         when "require_relative"
-          current_file = T.must(URI.parse(@uri).path)
-          current_folder = Pathname.new(current_file).dirname
+          path = @uri.to_standardized_path
+          current_folder = path ? Pathname.new(CGI.unescape(path)).dirname : Dir.pwd
           candidate = File.expand_path(File.join(current_folder, required_file))
 
           if candidate
             @response = Interface::Location.new(
-              uri: "file://#{candidate}",
+              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),
@@ -79,6 +102,30 @@ module RubyLsp
 
       private
 
+      sig { params(value: String).void }
+      def find_in_index(value)
+        entries = @index.resolve(value, @nesting)
+        return unless entries
+
+        workspace_path = T.must(WORKSPACE_URI.to_standardized_path)
+
+        @response = entries.filter_map do |entry|
+          location = entry.location
+          # 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. Sorbet can already handle go to definition for all constants
+          # in the project, even if the files are typed false
+          next if HAS_TYPECHECKER && entry.file_path.start_with?(workspace_path)
+
+          Interface::Location.new(
+            uri: URI::Generic.from_path(path: entry.file_path).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),
+            ),
+          )
+        end
+      end
+
       sig { params(file: String).returns(T.nilable(String)) }
       def find_file_in_load_path(file)
         return unless file.include?("/")

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -25,7 +25,7 @@ module RubyLsp
       def initialize(document)
         super(document)
 
-        @uri = T.let(document.uri, String)
+        @uri = T.let(document.uri, URI::Generic)
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Support::RuboCopDiagnostic], Object))) }
@@ -36,7 +36,8 @@ module RubyLsp
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
         # Don't try to run RuboCop diagnostics for files outside the current working directory
-        return unless URI(@uri).path&.start_with?(T.must(WORKSPACE_URI.path))
+        path = @uri.to_standardized_path
+        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
 
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end

data/lib/ruby_lsp/requests/document_link.rb

@@ -75,13 +75,14 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :response
 
-      sig { params(uri: String, emitter: EventEmitter, message_queue: Thread::Queue).void }
+      sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(uri, emitter, message_queue)
         super(emitter, message_queue)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI
-        version_match = /(?<=%40)[\d.]+(?=\.rbi$)/.match(uri)
+        path = uri.to_standardized_path
+        version_match = path ? /(?<=%40)[\d.]+(?=\.rbi$)/.match(path) : nil
         @gem_version = T.let(version_match && version_match[0], T.nilable(String))
         @response = T.let([], T::Array[Interface::DocumentLink])
 
@@ -95,7 +96,7 @@ module RubyLsp
 
         uri = T.cast(URI(T.must(match[0])), URI::Source)
         gem_version = T.must(resolve_version(uri))
-        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, uri.path)
+        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, CGI.unescape(uri.path))
         return if file_path.nil?
 
         @response << Interface::DocumentLink.new(