ruby-lsp 0.9.4 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a300c17567fae60c2ed50c941d8ada19bf6b6fd951b621029880c03afd6d6f5
-  data.tar.gz: 297d0d2064fbe7e97783e26fbfbdbb2191b6a32a43636e743864ad08665f49dd
+  metadata.gz: 98731986ff16a22d1854fe971bfa188d55212665128ad635aabbf519c1097d9f
+  data.tar.gz: fe416e79e672448b3d2477909fec47451c6f878020ec92e2178259d933c51cb4
 SHA512:
-  metadata.gz: ee884d5c7f60e1d3fac9069a170967a761407a6470b7fe7442686bdbdfc1a4cbd626b7bcd4d368072bce0bab349df935bc0e7e9bdcad7b2fa238143afbc78075
-  data.tar.gz: 317ebe547e3a9730c0161a2ad8b0dd130e819bf92a97c59525e5bc40e1e84bc95e0e610f87f144aebef957a622e141254938954bafd354e7f3d1249e022d2edb
+  metadata.gz: ad9a36886ffb6b1370b2530ffdb84a89244e22ec2329ee111d70bea8e90ad7ebe6c92b87dd437e283270cb09a7d564b3471d7ddcdc51df86df54d4bdfd09ada8
+  data.tar.gz: 9a89e7a763d1a74a320ca8dd544a52ead86a3bd573204ad86585dce7dc7797ac993f3716b98e9e6cdfd9d5b6b7a8f17e9743aa149866945d099e7d9210719a28

data/VERSION

@@ -1 +1 @@
-0.9.4
+0.10.0

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

@@ -28,7 +28,7 @@ module RubyIndexer
       @files_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])
 
       # Holds all require paths for every indexed item so that we can provide autocomplete for requires
-      @require_paths_tree = T.let(PrefixTree[String].new, PrefixTree[String])
+      @require_paths_tree = T.let(PrefixTree[IndexablePath].new, PrefixTree[IndexablePath])
     end
 
     sig { params(indexable: IndexablePath).void }
@@ -73,7 +73,7 @@ module RubyIndexer
       @entries[fully_qualified_name.delete_prefix("::")]
     end
 
-    sig { params(query: String).returns(T::Array[String]) }
+    sig { params(query: String).returns(T::Array[IndexablePath]) }
     def search_require_paths(query)
       @require_paths_tree.search(query)
     end
@@ -147,7 +147,7 @@ module RubyIndexer
       visitor.run
 
       require_path = indexable_path.require_path
-      @require_paths_tree.insert(require_path, require_path) if require_path
+      @require_paths_tree.insert(require_path, indexable_path) if require_path
     rescue Errno::EISDIR
       # If `path` is a directory, just ignore it and continue indexing
     end

data/lib/ruby_indexer/test/index_test.rb

@@ -136,7 +136,7 @@ module RubyIndexer
         end
       RUBY
 
-      assert_equal(["path/foo", "path/other_foo"], @index.search_require_paths("path"))
+      assert_equal(["path/foo", "path/other_foo"], @index.search_require_paths("path").map(&:require_path))
     end
 
     def test_searching_for_entries_based_on_prefix

data/lib/ruby_lsp/check_docs.rb

@@ -53,7 +53,8 @@ module RubyLsp
       # documented
       features = ObjectSpace.each_object(Class).filter_map do |k|
         klass = T.unsafe(k)
-        klass if klass < RubyLsp::Requests::BaseRequest || klass < RubyLsp::Listener
+        klass if klass < RubyLsp::Requests::BaseRequest ||
+          (klass < RubyLsp::Listener && klass != RubyLsp::ExtensibleListener)
       end
 
       missing_docs = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])

data/lib/ruby_lsp/event_emitter.rb

@@ -48,6 +48,8 @@ module RubyLsp
         @listeners[:on_const_path_ref]&.each { |l| T.unsafe(l).on_const_path_ref(node) }
       when SyntaxTree::Const
         @listeners[:on_const]&.each { |l| T.unsafe(l).on_const(node) }
+      when SyntaxTree::TopConstRef
+        @listeners[:on_top_const_ref]&.each { |l| T.unsafe(l).on_top_const_ref(node) }
       end
     end
 

data/lib/ruby_lsp/executor.rb

@@ -103,9 +103,6 @@ module RubyLsp
         semantic_highlighting = Requests::SemanticHighlighting.new(emitter, @message_queue)
         emitter.visit(document.tree) if document.parsed?
 
-        code_lens.merge_external_listeners_responses!
-        document_symbol.merge_external_listeners_responses!
-
         # Store all responses retrieve in this round of visits in the cache and then return the response for the request
         # we actually received
         document.cache_set("textDocument/documentSymbol", document_symbol.response)
@@ -299,7 +296,6 @@ module RubyLsp
       # Emit events for all listeners
       emitter.emit_for_target(target)
 
-      hover.merge_external_listeners_responses!
       hover.response
     end
 
@@ -478,12 +474,18 @@ module RubyLsp
       return unless document.parsed?
 
       char_position = document.create_scanner.find_char_position(position)
-      matched, parent = document.locate(
-        T.must(document.tree),
-        char_position,
-        node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
-      )
 
+      # When the user types in the first letter of a constant name, we actually receive the position of the next
+      # immediate character. We check to see if the character is uppercase and then remove the offset to try to locate
+      # the node, as it could not be a constant
+      target_node_types = if ("A".."Z").cover?(document.source[char_position - 1])
+        char_position -= 1
+        [SyntaxTree::Const, SyntaxTree::ConstPathRef, SyntaxTree::TopConstRef]
+      else
+        [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode]
+      end
+
+      matched, parent, nesting = document.locate(T.must(document.tree), char_position, node_types: target_node_types)
       return unless matched && parent
 
       target = case matched
@@ -504,12 +506,19 @@ module RubyLsp
         return unless (path_node.location.start_char..path_node.location.end_char).cover?(char_position)
 
         path_node
+      when SyntaxTree::Const, SyntaxTree::ConstPathRef
+        if (parent.is_a?(SyntaxTree::ConstPathRef) || parent.is_a?(SyntaxTree::TopConstRef)) &&
+            matched.is_a?(SyntaxTree::Const)
+          parent
+        else
+          matched
+        end
       end
 
       return unless target
 
       emitter = EventEmitter.new
-      listener = Requests::PathCompletion.new(@index, emitter, @message_queue)
+      listener = Requests::Completion.new(@index, nesting, emitter, @message_queue)
       emitter.emit_for_target(target)
       listener.response
     end
@@ -645,7 +654,10 @@ module RubyLsp
       completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
-          trigger_characters: ["/"],
+          trigger_characters: ["/", *"A".."Z"],
+          completion_item: {
+            labelDetailsSupport: true,
+          },
         )
       end
 

data/lib/ruby_lsp/extension.rb

@@ -133,5 +133,17 @@ module RubyLsp
       ).returns(T.nilable(Listener[T::Array[Interface::DocumentSymbol]]))
     end
     def create_document_symbol_listener(emitter, message_queue); end
+
+    # Creates a new Definition listener. This method is invoked on every Definition request
+    sig do
+      overridable.params(
+        uri: URI::Generic,
+        nesting: T::Array[String],
+        index: RubyIndexer::Index,
+        emitter: EventEmitter,
+        message_queue: Thread::Queue,
+      ).returns(T.nilable(Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]))
+    end
+    def create_definition_listener(uri, nesting, index, emitter, message_queue); end
   end
 end

data/lib/ruby_lsp/listener.rb

@@ -18,13 +18,42 @@ module RubyLsp
     def initialize(emitter, message_queue)
       @emitter = emitter
       @message_queue = message_queue
-      @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
+    end
+
+    sig { returns(ResponseType) }
+    def response
+      _response
     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
+    def _response; end
+  end
+
+  # ExtensibleListener is an abstract class to be used by requests that accept extensions.
+  class ExtensibleListener < Listener
+    extend T::Sig
+    extend T::Generic
+
+    ResponseType = type_member
+
+    abstract!
+
+    # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
+    # ivars have been initialized. This is because the constructor of ExtensibleListener calls
+    # `initialize_external_listener` which may depend on the subclass's ivars.
+    sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+    def initialize(emitter, message_queue)
+      super
+      @response_merged = T.let(false, T::Boolean)
+      @external_listeners = T.let(
+        Extension.extensions.filter_map do |ext|
+          initialize_external_listener(ext)
+        end,
+        T::Array[RubyLsp::Listener[ResponseType]],
+      )
+    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
@@ -33,11 +62,21 @@ module RubyLsp
       @external_listeners.each { |l| merge_response!(l) }
     end
 
+    sig { returns(ResponseType) }
+    def response
+      merge_external_listeners_responses! unless @response_merged
+      super
+    end
+
+    sig do
+      abstract.params(extension: RubyLsp::Extension).returns(T.nilable(RubyLsp::Listener[ResponseType]))
+    end
+    def initialize_external_listener(extension); 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) }
+    sig { abstract.params(other: Listener[T.untyped]).returns(T.self_type) }
     def merge_response!(other)
-      self
     end
   end
 end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -18,7 +18,7 @@ module RubyLsp
     # class Test < Minitest::Test
     # end
     # ```
-    class CodeLens < Listener
+    class CodeLens < ExtensibleListener
       extend T::Sig
       extend T::Generic
 
@@ -29,23 +29,20 @@ module RubyLsp
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       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, 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)
+        @_response = T.let([], ResponseType)
         @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])
 
+        super(emitter, message_queue)
+
         emitter.register(
           self,
           :on_class,
@@ -149,9 +146,14 @@ module RubyLsp
         end
       end
 
+      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(extension)
+        extension.create_code_lens_listener(@uri, @emitter, @message_queue)
+      end
+
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
-        @response.concat(other.response)
+        @_response.concat(other.response)
         self
       end
 
@@ -174,7 +176,7 @@ module RubyLsp
           },
         ]
 
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
@@ -182,7 +184,7 @@ module RubyLsp
           data: { type: "test", kind: kind },
         )
 
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
@@ -190,7 +192,7 @@ module RubyLsp
           data: { type: "test_in_terminal", kind: kind },
         )
 
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Debug",
           command_name: "rubyLsp.debugTest",
@@ -239,7 +241,7 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Command, remote: String).void }
       def add_open_gem_remote_code_lens(node, remote)
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Open remote",
           command_name: "rubyLsp.openLink",

data/lib/ruby_lsp/requests/completion.rb

@@ -0,0 +1,168 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Completion demo](../../completion.gif)
+    #
+    # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
+    # suggests possible completions according to what the developer is typing. Currently, completion is support for
+    # - require paths
+    # - classes, modules and constant names
+    #
+    # # Example
+    #
+    # ```ruby
+    # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
+    #
+    # RubyLsp::Requests:: # --> completion: suggests `Completion`, `Hover`, ...
+    # ```
+    class Completion < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
+
+      sig { override.returns(ResponseType) }
+      attr_reader :_response
+
+      sig do
+        params(
+          index: RubyIndexer::Index,
+          nesting: T::Array[String],
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(index, nesting, emitter, message_queue)
+        super(emitter, message_queue)
+        @_response = T.let([], ResponseType)
+        @index = index
+        @nesting = nesting
+
+        emitter.register(self, :on_tstring_content, :on_const_path_ref, :on_const, :on_top_const_ref)
+      end
+
+      sig { params(node: SyntaxTree::TStringContent).void }
+      def on_tstring_content(node)
+        @index.search_require_paths(node.value).map!(&:require_path).sort!.each do |path|
+          @_response << build_completion(T.must(path), node)
+        end
+      end
+
+      # Handle completion on regular constant references (e.g. `Bar`)
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = node.value
+        candidates = @index.prefix_search(name, @nesting)
+        candidates.each do |entries|
+          @_response << build_entry_completion(name, node, entries, top_level?(T.must(entries.first).name, candidates))
+        end
+      end
+
+      # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = full_constant_name(node)
+        candidates = @index.prefix_search(name, @nesting)
+        candidates.each do |entries|
+          @_response << build_entry_completion(name, node, entries, top_level?(T.must(entries.first).name, candidates))
+        end
+      end
+
+      # Handle completion on top level constant references (e.g. `::Bar`)
+      sig { params(node: SyntaxTree::TopConstRef).void }
+      def on_top_const_ref(node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = full_constant_name(node)
+        candidates = @index.prefix_search(name, [])
+        candidates.each { |entries| @_response << build_entry_completion(name, node, entries, true) }
+      end
+
+      private
+
+      sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
+      def build_completion(label, node)
+        Interface::CompletionItem.new(
+          label: label,
+          text_edit: Interface::TextEdit.new(
+            range: range_from_syntax_tree_node(node),
+            new_text: label,
+          ),
+          kind: Constant::CompletionItemKind::REFERENCE,
+        )
+      end
+
+      sig do
+        params(
+          name: String,
+          node: SyntaxTree::Node,
+          entries: T::Array[RubyIndexer::Index::Entry],
+          top_level: T::Boolean,
+        ).returns(Interface::CompletionItem)
+      end
+      def build_entry_completion(name, node, entries, top_level)
+        first_entry = T.must(entries.first)
+        kind = case first_entry
+        when RubyIndexer::Index::Entry::Class
+          Constant::CompletionItemKind::CLASS
+        when RubyIndexer::Index::Entry::Module
+          Constant::CompletionItemKind::MODULE
+        when RubyIndexer::Index::Entry::Constant
+          Constant::CompletionItemKind::CONSTANT
+        else
+          Constant::CompletionItemKind::REFERENCE
+        end
+
+        insertion_text = first_entry.name.dup
+
+        # If we have two entries with the same name inside the current namespace and the user selects the top level
+        # option, we have to ensure it's prefixed with `::` or else we're completing the wrong constant. For example:
+        # If we have the index with ["Foo::Bar", "Bar"], and we're providing suggestions for `B` inside a `Foo` module,
+        # then selecting the `Foo::Bar` option needs to complete to `Bar` and selecting the top level `Bar` option needs
+        # to complete to `::Bar`.
+        insertion_text.prepend("::") if top_level
+
+        # If the user is searching for a constant inside the current namespace, then we prefer completing the short name
+        # of that constant. E.g.:
+        #
+        # module Foo
+        #  class Bar
+        #  end
+        #
+        #  Foo::B # --> completion inserts `Bar` instead of `Foo::Bar`
+        # end
+        @nesting.each { |namespace| insertion_text.delete_prefix!("#{namespace}::") }
+
+        # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
+        # For these top level references, we need to include the `::` as part of the filter text or else it won't match
+        # the right entries in the index
+        Interface::CompletionItem.new(
+          label: first_entry.name,
+          filter_text: top_level ? "::#{first_entry.name}" : first_entry.name,
+          text_edit: Interface::TextEdit.new(
+            range: range_from_syntax_tree_node(node),
+            new_text: insertion_text,
+          ),
+          kind: kind,
+          label_details: Interface::CompletionItemLabelDetails.new(
+            description: entries.map(&:file_name).join(","),
+          ),
+          documentation: markdown_from_index_entries(first_entry.name, entries),
+        )
+      end
+
+      # Check if the `entry_name` has potential conflicts in `candidates`, so that we use a top level reference instead
+      # of a short name
+      sig { params(entry_name: String, candidates: T::Array[T::Array[RubyIndexer::Index::Entry]]).returns(T::Boolean) }
+      def top_level?(entry_name, candidates)
+        candidates.any? { |entries| T.must(entries.first).name == "#{@nesting.join("::")}::#{entry_name}" }
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/definition.rb

@@ -17,14 +17,14 @@ module RubyLsp
     # require "some_gem/file" # <- Request go to definition on this string will take you to the file
     # Product.new # <- Request go to definition on this class name will take you to its declaration.
     # ```
-    class Definition < Listener
+    class Definition < ExtensibleListener
       extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { fixed: T.nilable(T.any(T::Array[Interface::Location], Interface::Location)) } }
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig do
         params(
@@ -36,15 +36,37 @@ module RubyLsp
         ).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)
+        @_response = T.let(nil, ResponseType)
+
+        super(emitter, message_queue)
+
         emitter.register(self, :on_command, :on_const, :on_const_path_ref)
       end
 
+      sig { override.params(ext: Extension).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
+      def initialize_external_listener(ext)
+        ext.create_definition_listener(@uri, @nesting, @index, @emitter, @message_queue)
+      end
+
+      sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
+      def merge_response!(other)
+        other_response = other._response
+
+        case @_response
+        when Interface::Location
+          @_response = [@_response, *other_response]
+        when Array
+          @_response.concat(Array(other_response))
+        when nil
+          @_response = other_response
+        end
+
+        self
+      end
+
       sig { params(node: SyntaxTree::ConstPathRef).void }
       def on_const_path_ref(node)
         name = full_constant_name(node)
@@ -67,14 +89,16 @@ module RubyLsp
         string = argument.parts.first
         return unless string.is_a?(SyntaxTree::TStringContent)
 
-        required_file = "#{string.value}.rb"
-
         case message
         when "require"
-          candidate = find_file_in_load_path(required_file)
+          entry = @index.search_require_paths(string.value).find do |indexable_path|
+            indexable_path.require_path == string.value
+          end
+
+          if entry
+            candidate = entry.full_path
 
-          if candidate
-            @response = Interface::Location.new(
+            @_response = Interface::Location.new(
               uri: URI::Generic.from_path(path: candidate).to_s,
               range: Interface::Range.new(
                 start: Interface::Position.new(line: 0, character: 0),
@@ -83,19 +107,18 @@ module RubyLsp
             )
           end
         when "require_relative"
+          required_file = "#{string.value}.rb"
           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: 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
+          @_response = 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
 
@@ -112,7 +135,7 @@ module RubyLsp
           nil
         end
 
-        @response = entries.filter_map do |entry|
+        @_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
@@ -133,18 +156,6 @@ module RubyLsp
           )
         end
       end
-
-      sig { params(file: String).returns(T.nilable(String)) }
-      def find_file_in_load_path(file)
-        return unless file.include?("/")
-
-        $LOAD_PATH.each do |p|
-          found = Dir.glob("**/#{file}", base: p).first
-          return "#{p}/#{found}" if found
-        end
-
-        nil
-      end
     end
   end
 end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -28,7 +28,7 @@ module RubyLsp
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentHighlight] } }
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig do
         params(
@@ -41,7 +41,7 @@ module RubyLsp
       def initialize(target, parent, emitter, message_queue)
         super(emitter, message_queue)
 
-        @response = T.let([], T::Array[Interface::DocumentHighlight])
+        @_response = T.let([], T::Array[Interface::DocumentHighlight])
 
         return unless target && parent
 
@@ -83,7 +83,7 @@ module RubyLsp
       sig { params(match: Support::HighlightTarget::HighlightMatch).void }
       def add_highlight(match)
         range = range_from_syntax_tree_node(match.node)
-        @response << Interface::DocumentHighlight.new(range: range, kind: match.type)
+        @_response << Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/document_link.rb

@@ -73,7 +73,7 @@ module RubyLsp
       end
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(uri, emitter, message_queue)
@@ -84,7 +84,7 @@ module RubyLsp
         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])
+        @_response = T.let([], T::Array[Interface::DocumentLink])
 
         emitter.register(self, :on_comment)
       end
@@ -99,7 +99,7 @@ module RubyLsp
         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(
+        @_response << Interface::DocumentLink.new(
           range: range_from_syntax_tree_node(node),
           target: "file://#{file_path}##{uri.line_number}",
           tooltip: "Jump to #{file_path}##{uri.line_number}",

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -26,7 +26,7 @@ module RubyLsp
     #   end
     # end
     # ```
-    class DocumentSymbol < Listener
+    class DocumentSymbol < ExtensibleListener
       extend T::Sig
       extend T::Generic
 
@@ -47,22 +47,18 @@ module RubyLsp
       end
 
       sig { override.returns(T::Array[Interface::DocumentSymbol]) }
-      attr_reader :response
+      attr_reader :_response
 
       sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(emitter, message_queue)
-        super
-
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
-        @response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
+        @_response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
         @stack = T.let(
           [@root],
           T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
         )
 
-        @external_listeners.concat(
-          Extension.extensions.filter_map { |ext| ext.create_document_symbol_listener(emitter, message_queue) },
-        )
+        super
 
         emitter.register(
           self,
@@ -79,10 +75,15 @@ module RubyLsp
         )
       end
 
+      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(extension)
+        extension.create_document_symbol_listener(@emitter, @message_queue)
+      end
+
       # Merges responses from other listeners
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
-        @response.concat(other.response)
+        @_response.concat(other.response)
         self
       end
 

data/lib/ruby_lsp/requests/hover.rb

@@ -13,7 +13,7 @@ module RubyLsp
     # ```ruby
     # String # -> Hovering over the class reference will show all declaration locations and the documentation
     # ```
-    class Hover < Listener
+    class Hover < ExtensibleListener
       extend T::Sig
       extend T::Generic
 
@@ -30,7 +30,7 @@ module RubyLsp
       )
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig do
         params(
@@ -41,27 +41,29 @@ module RubyLsp
         ).void
       end
       def initialize(index, nesting, emitter, message_queue)
-        super(emitter, message_queue)
-
         @nesting = nesting
         @index = index
-        @external_listeners.concat(
-          Extension.extensions.filter_map { |ext| ext.create_hover_listener(emitter, message_queue) },
-        )
-        @response = T.let(nil, ResponseType)
+        @_response = T.let(nil, ResponseType)
+
+        super(emitter, message_queue)
         emitter.register(self, :on_const_path_ref, :on_const)
       end
 
+      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(extension)
+        extension.create_hover_listener(@emitter, @message_queue)
+      end
+
       # Merges responses from other hover listeners
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
         other_response = other.response
         return self unless other_response
 
-        if @response.nil?
-          @response = other.response
+        if @_response.nil?
+          @_response = other.response
         else
-          @response.contents.value << "\n\n" << other_response.contents.value
+          @_response.contents.value << "\n\n" << other_response.contents.value
         end
 
         self
@@ -89,29 +91,10 @@ module RubyLsp
         entries = @index.resolve(name, @nesting)
         return unless entries
 
-        title = +"```ruby\n#{name}\n```"
-        definitions = []
-        content = +""
-        entries.each do |entry|
-          loc = entry.location
-
-          # We always handle locations as zero based. However, for file links in Markdown we need them to be one 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}",
-          )
-
-          definitions << "[#{entry.file_name}](#{uri})"
-          content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
-        end
-
-        contents = Interface::MarkupContent.new(
-          kind: "markdown",
-          value: "#{title}\n\n**Definitions**: #{definitions.join(" | ")}\n\n#{content}",
+        @_response = Interface::Hover.new(
+          range: range_from_syntax_tree_node(node),
+          contents: markdown_from_index_entries(name, entries),
         )
-        @response = Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
     end
   end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -27,13 +27,13 @@ module RubyLsp
       RESCUE_STRING_LENGTH = T.let("rescue".length, Integer)
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig { params(range: T::Range[Integer], emitter: EventEmitter, message_queue: Thread::Queue).void }
       def initialize(range, emitter, message_queue)
         super(emitter, message_queue)
 
-        @response = T.let([], ResponseType)
+        @_response = T.let([], ResponseType)
         @range = range
 
         emitter.register(self, :on_rescue)
@@ -47,7 +47,7 @@ module RubyLsp
         loc = node.location
         return unless visible?(node, @range)
 
-        @response << Interface::InlayHint.new(
+        @_response << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -105,7 +105,7 @@ module RubyLsp
       end
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig do
         params(
@@ -117,7 +117,7 @@ module RubyLsp
       def initialize(emitter, message_queue, range: nil)
         super(emitter, message_queue)
 
-        @response = T.let([], ResponseType)
+        @_response = T.let([], ResponseType)
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
 
@@ -174,7 +174,7 @@ module RubyLsp
         # When finding a module or class definition, we will have already pushed a token related to this constant. We
         # need to look at the previous two tokens and if they match this locatione exactly, avoid pushing another token
         # on top of the previous one
-        return if @response.last(2).any? { |token| token.location == node.location }
+        return if @_response.last(2).any? { |token| token.location == node.location }
 
         add_token(node.location, :namespace)
       end
@@ -327,7 +327,7 @@ module RubyLsp
       def add_token(location, type, modifiers = [])
         length = location.end_char - location.start_char
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
-        @response.push(
+        @_response.push(
           SemanticToken.new(
             location: location,
             length: length,

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

@@ -74,6 +74,39 @@ module RubyLsp
             data: data,
           )
         end
+
+        sig { params(title: String, entries: T::Array[RubyIndexer::Index::Entry]).returns(Interface::MarkupContent) }
+        def markdown_from_index_entries(title, entries)
+          markdown_title = "```ruby\n#{title}\n```"
+          definitions = []
+          content = +""
+          entries.each do |entry|
+            loc = entry.location
+
+            # We always handle locations as zero based. However, for file links in Markdown we need them to be one
+            # 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}",
+            )
+
+            definitions << "[#{entry.file_name}](#{uri})"
+            content << "\n\n#{entry.comments.join("\n")}" unless entry.comments.empty?
+          end
+
+          Interface::MarkupContent.new(
+            kind: "markdown",
+            value: <<~MARKDOWN.chomp,
+              #{markdown_title}
+
+              **Definitions**: #{definitions.join(" | ")}
+
+              #{content}
+            MARKDOWN
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/requests.rb

@@ -17,7 +17,7 @@ module RubyLsp
   # - [CodeActionResolve](rdoc-ref:RubyLsp::Requests::CodeActionResolve)
   # - [DocumentHighlight](rdoc-ref:RubyLsp::Requests::DocumentHighlight)
   # - [InlayHint](rdoc-ref:RubyLsp::Requests::InlayHints)
-  # - [PathCompletion](rdoc-ref:RubyLsp::Requests::PathCompletion)
+  # - [Completion](rdoc-ref:RubyLsp::Requests::Completion)
   # - [CodeLens](rdoc-ref:RubyLsp::Requests::CodeLens)
   # - [Definition](rdoc-ref:RubyLsp::Requests::Definition)
   # - [ShowSyntaxTree](rdoc-ref:RubyLsp::Requests::ShowSyntaxTree)
@@ -38,7 +38,7 @@ module RubyLsp
     autoload :CodeActionResolve, "ruby_lsp/requests/code_action_resolve"
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
-    autoload :PathCompletion, "ruby_lsp/requests/path_completion"
+    autoload :Completion, "ruby_lsp/requests/completion"
     autoload :CodeLens, "ruby_lsp/requests/code_lens"
     autoload :Definition, "ruby_lsp/requests/definition"
     autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: 0.10.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-05 00:00:00.000000000 Z
+date: 2023-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -119,6 +119,7 @@ files:
 - lib/ruby_lsp/requests/code_action_resolve.rb
 - lib/ruby_lsp/requests/code_actions.rb
 - lib/ruby_lsp/requests/code_lens.rb
+- lib/ruby_lsp/requests/completion.rb
 - lib/ruby_lsp/requests/definition.rb
 - lib/ruby_lsp/requests/diagnostics.rb
 - lib/ruby_lsp/requests/document_highlight.rb
@@ -129,7 +130,6 @@ files:
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
-- lib/ruby_lsp/requests/path_completion.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
 - lib/ruby_lsp/requests/show_syntax_tree.rb

data/lib/ruby_lsp/requests/path_completion.rb

@@ -1,56 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  module Requests
-    # ![Path completion demo](../../path_completion.gif)
-    #
-    # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
-    # request looks up Ruby files in the $LOAD_PATH to suggest path completion inside `require` statements.
-    #
-    # # Example
-    #
-    # ```ruby
-    # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
-    # ```
-    class PathCompletion < Listener
-      extend T::Sig
-      extend T::Generic
-
-      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
-
-      sig { override.returns(ResponseType) }
-      attr_reader :response
-
-      sig { params(index: RubyIndexer::Index, emitter: EventEmitter, message_queue: Thread::Queue).void }
-      def initialize(index, emitter, message_queue)
-        super(emitter, message_queue)
-        @response = T.let([], ResponseType)
-        @index = index
-
-        emitter.register(self, :on_tstring_content)
-      end
-
-      sig { params(node: SyntaxTree::TStringContent).void }
-      def on_tstring_content(node)
-        @index.search_require_paths(node.value).sort!.each do |path|
-          @response << build_completion(path, node)
-        end
-      end
-
-      private
-
-      sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
-      def build_completion(label, node)
-        Interface::CompletionItem.new(
-          label: label,
-          text_edit: Interface::TextEdit.new(
-            range: range_from_syntax_tree_node(node),
-            new_text: label,
-          ),
-          kind: Constant::CompletionItemKind::REFERENCE,
-        )
-      end
-    end
-  end
-end